1. 一篇文章帶你深度解析python線程和進程
使用Python中的線程模塊，能夠同時運行程序的不同部分，並簡化設計。如果你已經入門Python，並且想用線程來提升程序運行速度的話，希望這篇教程會對你有所幫助。
線程與進程
什麼是進程
進程是系統進行資源分配和調度的一個獨立單位 進程是具有一定獨立功能的程序關於某個數據集合上的一次運行活動,進程是系統進行資源分配和調度的一個獨立單位。每個進程都有自己的獨立內存空間，不同進程通過進程間通信來通信。由於進程比較重量，占據獨立的內存，所以上下文進程間的切換開銷（棧、寄存器、虛擬內存、文件句柄等）比較大，但相對比較穩定安全。
什麼是線程
CPU調度和分派的基本單位 線程是進程的一個實體，是CPU調度和分派的基本單位,它是比進程更小的能獨立運行的基本單位.線程自己基本上不擁有系統資源,只擁有一點在運行中必不可少的資源(如程序計數器,一組寄存器和棧),但是它可與同屬一個進程的其他的線程共享進程所擁有的全部資源。線程間通信主要通過共享內存，上下文切換很快，資源開銷較少，但相比進程不夠穩定容易丟失數據。
進程與線程的關系圖
線程與進程的區別：
進程
現實生活中，有很多的場景中的事情是同時進行的，比如開車的時候 手和腳共同來駕駛 汽車 ，比如唱歌跳舞也是同時進行的，再比如邊吃飯邊打電話；試想如果我們吃飯的時候有一個領導來電，我們肯定是立刻就接聽了。但是如果你吃完飯再接聽或者回電話，很可能會被開除。
注意：
多任務的概念
什麼叫 多任務 呢？簡單地說，就是操作系統可以同時運行多個任務。打個比方，你一邊在用瀏覽器上網，一邊在聽MP3，一邊在用Word趕作業，這就是多任務，至少同時有3個任務正在運行。還有很多任務悄悄地在後台同時運行著，只是桌面上沒有顯示而已。
現在，多核CPU已經非常普及了，但是，即使過去的單核CPU，也可以執行多任務。由於CPU執行代碼都是順序執行的，那麼，單核CPU是怎麼執行多任務的呢？
答案就是操作系統輪流讓各個任務交替執行，任務1執行0.01秒，切換到任務2，任務2執行0.01秒，再切換到任務3，執行0.01秒，這樣反復執行下去。表面上看，每個任務都是交替執行的，但是，由於CPU的執行速度實在是太快了，我們感覺就像所有任務都在同時執行一樣。
真正的並行執行多任務只能在多核CPU上實現，但是，由於任務數量遠遠多於CPU的核心數量，所以，操作系統也會自動把很多任務輪流調度到每個核心上執行。 其實就是CPU執行速度太快啦！以至於我們感受不到在輪流調度。
並行與並發
並行（Parallelism）
並行：指兩個或兩個以上事件（或線程）在同一時刻發生，是真正意義上的不同事件或線程在同一時刻，在不同CPU資源呢上（多核），同時執行。
特點
並發（Concurrency）
指一個物理CPU(也可以多個物理CPU) 在若幹道程序（或線程）之間多路復用，並發性是對有限物理資源強制行使多用戶共享以提高效率。
特點
multiprocess.Process模塊
process模塊是一個創建進程的模塊，藉助這個模塊，就可以完成進程的創建。
語法：Process([group [, target [, name [, args [, kwargs]]]]])
由該類實例化得到的對象，表示一個子進程中的任務（尚未啟動）。
注意：1. 必須使用關鍵字方式來指定參數；2. args指定的為傳給target函數的位置參數，是一個元祖形式，必須有逗號。
參數介紹：
group：參數未使用，默認值為None。
target：表示調用對象，即子進程要執行的任務。
args：表示調用的位置參數元祖。
kwargs：表示調用對象的字典。如kwargs = {'name':Jack, 'age':18}。
name：子進程名稱。
代碼：
除了上面這些開啟進程的方法之外，還有一種以繼承Process的方式開啟進程的方式：
通過上面的研究，我們千方百計實現了程序的非同步，讓多個任務可以同時在幾個進程中並發處理，他們之間的運行沒有順序，一旦開啟也不受我們控制。盡管並發編程讓我們能更加充分的利用IO資源，但是也給我們帶來了新的問題。
當多個進程使用同一份數據資源的時候，就會引發數據安全或順序混亂問題，我們可以考慮加鎖，我們以模擬搶票為例，來看看數據安全的重要性。
加鎖可以保證多個進程修改同一塊數據時，同一時間只能有一個任務可以進行修改，即串列的修改。加鎖犧牲了速度，但是卻保證了數據的安全。
因此我們最好找尋一種解決方案能夠兼顧：1、效率高（多個進程共享一塊內存的數據）2、幫我們處理好鎖問題。
mutiprocessing模塊為我們提供的基於消息的IPC通信機制：隊列和管道。隊列和管道都是將數據存放於內存中 隊列又是基於（管道+鎖）實現的，可以讓我們從復雜的鎖問題中解脫出來， 我們應該盡量避免使用共享數據，盡可能使用消息傳遞和隊列，避免處理復雜的同步和鎖問題，而且在進程數目增多時，往往可以獲得更好的可獲展性（ 後續擴展該內容 ）。
線程
Python的threading模塊
Python 供了幾個用於多線程編程的模塊，包括 thread, threading 和 Queue 等。thread 和 threading 模塊允許程序員創建和管理線程。thread 模塊 供了基本的線程和鎖的支持，而 threading 供了更高級別，功能更強的線程管理的功能。Queue 模塊允許用戶創建一個可以用於多個線程之間 共享數據的隊列數據結構。
python創建和執行線程
創建線程代碼
1. 創建方法一:
2. 創建方法二:
進程和線程都是實現多任務的一種方式，例如：在同一台計算機上能同時運行多個QQ（進程),一個QQ可以打開多個聊天窗口（線程）。資源共享：進程不能共享資源，而線程共享所在進程的地址空間和其他資源，同時，線程有自己的棧和棧指針。所以在一個進程內的所有線程共享全局變數，但多線程對全局變數的更改會導致變數值得混亂。
代碼演示:
得到的結果是：
首先需要明確的一點是GIL並不是Python的特性，它是在實現Python解析器(CPython)時所引入的一個概念。就好比C++是一套語言（語法）標准，但是可以用不同的編譯器來編譯成可執行代碼。同樣一段代碼可以通過CPython，PyPy，Psyco等不同的Python執行環境來執行（其中的JPython就沒有GIL）。
那麼CPython實現中的GIL又是什麼呢？GIL全稱Global Interpreter Lock為了避免誤導，我們還是來看一下官方給出的解釋：
主要意思為:
因此，解釋器實際上被一個全局解釋器鎖保護著，它確保任何時候都只有一個Python線程執行。在多線程環境中，Python 虛擬機按以下方式執行:
由於GIL的存在，Python的多線程不能稱之為嚴格的多線程。因為 多線程下每個線程在執行的過程中都需要先獲取GIL，保證同一時刻只有一個線程在運行。
由於GIL的存在，即使是多線程，事實上同一時刻只能保證一個線程在運行， 既然這樣多線程的運行效率不就和單線程一樣了嗎，那為什麼還要使用多線程呢？
由於以前的電腦基本都是單核CPU，多線程和單線程幾乎看不出差別，可是由於計算機的迅速發展，現在的電腦幾乎都是多核CPU了，最少也是兩個核心數的，這時差別就出來了：通過之前的案例我們已經知道，即使在多核CPU中，多線程同一時刻也只有一個線程在運行，這樣不僅不能利用多核CPU的優勢，反而由於每個線程在多個CPU上是交替執行的，導致在不同CPU上切換時造成資源的浪費，反而會更慢。即原因是一個進程只存在一把gil鎖，當在執行多個線程時，內部會爭搶gil鎖，這會造成當某一個線程沒有搶到鎖的時候會讓cpu等待，進而不能合理利用多核cpu資源。
但是在使用多線程抓取網頁內容時，遇到IO阻塞時，正在執行的線程會暫時釋放GIL鎖，這時其它線程會利用這個空隙時間，執行自己的代碼，因此多線程抓取比單線程抓取性能要好，所以我們還是要使用多線程的。
GIL對多線程Python程序的影響
程序的性能受到計算密集型(CPU)的程序限制和I/O密集型的程序限制影響,那什麼是計算密集型和I/O密集型程序呢?
計算密集型：要進行大量的數值計算，例如進行上億的數字計算、計算圓周率、對視頻進行高清解碼等等。這種計算密集型任務雖然也可以用多任務完成，但是花費的主要時間在任務切換的時間，此時CPU執行任務的效率比較低。
IO密集型：涉及到網路請求(time.sleep())、磁碟IO的任務都是IO密集型任務，這類任務的特點是CPU消耗很少，任務的大部分時間都在等待IO操作完成（因為IO的速度遠遠低於CPU和內存的速度）。對於IO密集型任務，任務越多，CPU效率越高，但也有一個限度。
當然為了避免GIL對我們程序產生影響，我們也可以使用，線程鎖。
Lock&RLock
常用的資源共享鎖機制：有Lock、RLock、Semphore、Condition等，簡單給大家分享下Lock和RLock。
Lock
特點就是執行速度慢，但是保證了數據的安全性
RLock
使用鎖代碼操作不當就會產生死鎖的情況。
什麼是死鎖
死鎖：當線程A持有獨占鎖a，並嘗試去獲取獨占鎖b的同時，線程B持有獨占鎖b，並嘗試獲取獨占鎖a的情況下，就會發生AB兩個線程由於互相持有對方需要的鎖，而發生的阻塞現象，我們稱為死鎖。即死鎖是指多個進程因競爭資源而造成的一種僵局，若無外力作用，這些進程都將無法向前推進。
所以，在系統設計、進程調度等方面注意如何不讓這四個必要條件成立，如何確定資源的合理分配演算法，避免進程永久占據系統資源。
死鎖代碼
python線程間通信
如果各個線程之間各干各的，確實不需要通信，這樣的代碼也十分的簡單。但這一般是不可能的，至少線程要和主線程進行通信，不然計算結果等內容無法取回。而實際情況中要復雜的多，多個線程間需要交換數據，才能得到正確的執行結果。
python中Queue是消息隊列，提供線程間通信機制，python3中重名為為queue，queue模塊塊下提供了幾個阻塞隊列，這些隊列主要用於實現線程通信。
在 queue 模塊下主要提供了三個類，分別代表三種隊列，它們的主要區別就在於進隊列、出隊列的不同。
簡單代碼演示
此時代碼會阻塞，因為queue中內容已滿，此時可以在第四個queue.put('蘋果')後面添加timeout，則成為 queue.put('蘋果'，timeout=1)如果等待1秒鍾仍然是滿的就會拋出異常，可以捕獲異常。
同理如果隊列是空的，無法獲取到內容默認也會阻塞，如果不阻塞可以使用queue.get_nowait()。
在掌握了 Queue 阻塞隊列的特性之後，在下面程序中就可以利用 Queue 來實現線程通信了。
下面演示一個生產者和一個消費者，當然都可以多個
使用queue模塊，可在線程間進行通信，並保證了線程安全。
協程
協程，又稱微線程，纖程。英文名Coroutine。
協程是python個中另外一種實現多任務的方式，只不過比線程更小佔用更小執行單元（理解為需要的資源）。為啥說它是一個執行單元，因為它自帶CPU上下文。這樣只要在合適的時機， 我們可以把一個協程 切換到另一個協程。只要這個過程中保存或恢復 CPU上下文那麼程序還是可以運行的。
通俗的理解：在一個線程中的某個函數，可以在任何地方保存當前函數的一些臨時變數等信息，然後切換到另外一個函數中執行，注意不是通過調用函數的方式做到的，並且切換的次數以及什麼時候再切換到原來的函數都由開發者自己確定。
在實現多任務時，線程切換從系統層面遠不止保存和恢復 CPU上下文這么簡單。操作系統為了程序運行的高效性每個線程都有自己緩存Cache等等數據，操作系統還會幫你做這些數據的恢復操作。所以線程的切換非常耗性能。但是協程的切換只是單純的操作CPU的上下文，所以一秒鍾切換個上百萬次系統都抗的住。
greenlet與gevent
為了更好使用協程來完成多任務，除了使用原生的yield完成模擬協程的工作，其實python還有的greenlet模塊和gevent模塊，使實現協程變的更加簡單高效。
greenlet雖說實現了協程，但需要我們手工切換，太麻煩了，gevent是比greenlet更強大的並且能夠自動切換任務的模塊。
其原理是當一個greenlet遇到IO(指的是input output 輸入輸出，比如網路、文件操作等)操作時，比如訪問網路，就自動切換到其他的greenlet，等到IO操作完成，再在適當的時候切換回來繼續執行。
模擬耗時操作：
如果有耗時操作也可以換成，gevent中自己實現的模塊，這時候就需要打補丁了。
使用協程完成一個簡單的二手房信息的爬蟲代碼吧！
以下文章來源於Python專欄 ，作者宋宋
文章鏈接：https://mp.weixin.qq.com/s/2r3_ipU3HjdA5VnqSHjUnQ
2. Python多線程總結
在實際處理數據時，因系統內存有限，我們不可能一次把所有數據都導出進行操作，所以需要批量導出依次操作。為了加快運行，我們會採用多線程的方法進行數據處理， 以下為我總結的多線程批量處理數據的模板：
主要分為三大部分：
共分4部分對多線程的內容進行總結。
先為大家介紹線程的相關概念:
在飛車程序中，如果沒有多線程，我們就不能一邊聽歌一邊玩飛車，聽歌與玩 游戲 不能並行；在使用多線程後，我們就可以在玩 游戲 的同時聽背景音樂。在這個例子中啟動飛車程序就是一個進程，玩 游戲 和聽音樂是兩個線程。
Python 提供了 threading 模塊來實現多線程:
因為新建線程系統需要分配資源、終止線程系統需要回收資源，所以如果可以重用線程，則可以減去新建/終止的開銷以提升性能。同時，使用線程池的語法比自己新建線程執行線程更加簡潔。
Python 為我們提供了 ThreadPoolExecutor 來實現線程池，此線程池默認子線程守護。它的適應場景為突發性大量請求或需要大量線程完成任務，但實際任務處理時間較短。
其中 max_workers 為線程池中的線程個數，常用的遍歷方法有 map 和 submit+as_completed 。根據業務場景的不同，若我們需要輸出結果按遍歷順序返回，我們就用 map 方法，若想誰先完成就返回誰，我們就用 submit+as_complete 方法。
我們把一個時間段內只允許一個線程使用的資源稱為臨界資源，對臨界資源的訪問，必須互斥的進行。互斥，也稱間接制約關系。線程互斥指當一個線程訪問某臨界資源時，另一個想要訪問該臨界資源的線程必須等待。當前訪問臨界資源的線程訪問結束，釋放該資源之後，另一個線程才能去訪問臨界資源。鎖的功能就是實現線程互斥。
我把線程互斥比作廁所包間上大號的過程，因為包間里只有一個坑，所以只允許一個人進行大號。當第一個人要上廁所時，會將門上上鎖，這時如果第二個人也想大號，那就必須等第一個人上完，將鎖解開後才能進行，在這期間第二個人就只能在門外等著。這個過程與代碼中使用鎖的原理如出一轍，這里的坑就是臨界資源。 Python 的 threading 模塊引入了鎖。 threading 模塊提供了 Lock 類，它有如下方法加鎖和釋放鎖：
我們會發現這個程序只會列印「第一道鎖」，而且程序既沒有終止，也沒有繼續運行。這是因為 Lock 鎖在同一線程內第一次加鎖之後還沒有釋放時，就進行了第二次 acquire 請求，導致無法執行 release ，所以鎖永遠無法釋放，這就是死鎖。如果我們使用 RLock 就能正常運行，不會發生死鎖的狀態。
在主線程中定義 Lock 鎖，然後上鎖，再創建一個子 線程t 運行 main 函數釋放鎖，結果正常輸出，說明主線程上的鎖，可由子線程解鎖。
如果把上面的鎖改為 RLock 則報錯。在實際中設計程序時，我們會將每個功能分別封裝成一個函數，每個函數中都可能會有臨界區域，所以就需要用到 RLock 。
一句話總結就是 Lock 不能套娃， RLock 可以套娃； Lock 可以由其他線程中的鎖進行操作， RLock 只能由本線程進行操作。
3. python 線程池的使用
最近在做一個爬蟲相關的項目，單線程的整站爬蟲，耗時真的不是一般的巨大，運行一次也是心累，，，所以，要想實現整站爬蟲，多線程是不可避免的，那麼python多線程又應該怎樣實現呢？這里主要要幾個問題（關於python多線程的GIL問題就不再說了，網上太多了）。
一、 既然多線程可以縮短程序運行時間，那麼，是不是線程數量越多越好呢？
顯然，並不是，每一個線程的從生成到消亡也是需要時間和資源的，太多的線程會佔用過多的系統資源（內存開銷，cpu開銷），而且生成太多的線程時間也是可觀的，很可能會得不償失，這里給出一個最佳線程數量的計算方式：
最佳線程數的獲取：
1、通過用戶慢慢遞增來進行性能壓測，觀察QPS（即每秒的響應請求數，也即是最大吞吐能力。），響應時間
2、根據公式計算:伺服器端最佳線程數量=((線程等待時間+線程cpu時間)/線程cpu時間) * cpu數量
3、單用戶壓測，查看CPU的消耗，然後直接乘以百分比，再進行壓測，一般這個值的附近應該就是最佳線程數量。
二、為什麼要使用線程池？
對於任務數量不斷增加的程序，每有一個任務就生成一個線程，最終會導致線程數量的失控，例如，整站爬蟲，假設初始只有一個鏈接a，那麼，這個時候只啟動一個線程，運行之後，得到這個鏈接對應頁面上的b，c，d，，，等等新的鏈接，作為新任務，這個時候，就要為這些新的鏈接生成新的線程，線程數量暴漲。在之後的運行中，線程數量還會不停的增加，完全無法控制。所以，對於任務數量不端增加的程序，固定線程數量的線程池是必要的。
三、如何使用線程池
過去使用threadpool模塊，現在一般使用concurrent.futures模塊，這個模塊是python3中自帶的模塊，但是，python2.7以上版本也可以安裝使用，具體使用方式如下：
注意到：
concurrent.futures.ThreadPoolExecutor，在提交任務的時候，有兩種方式，一種是submit（）函數，另一種是map（）函數，兩者的主要區別在於：
4. python多線程
有很多的場景中的事情是同時進行的,比如開車的時候,手和腳共同來駕駛汽車,再比如唱歌跳舞也是同時進行的
結果:
• _thread
• threading(推薦使用)
結果:
threading.enumerate() 可查看當前正在運行的線程
結果:
結果:
結果:
結果: 出現資源競爭導致計算結果不正確
(1)當多個線程幾乎同時修改某一個共享數據的時候,需要進行同步控制
(2)線程同步能夠保證多個線程安全訪問資源,最簡單的同步機制是引入互斥鎖
(3)互斥鎖為資源引入一個狀態: 鎖定/非鎖定
(4)某個線程要更愛共享數據時,先將其鎖定,此時資源的狀態為"鎖定", 其他線程不能更改;直到該線程釋放資源,將資源狀態變為"非鎖定"
(5)互斥鎖保證了每次只有一個線程進行寫入操作,從而保證了多線程情況下數據的正確性
結果: 計算正確
結果:卡住了
在線程間共享多個資源的時候,如果兩個線程分別戰友一部分資源且同時等待對方資源,就會造成死鎖
(1)程序設計時避免(銀行家演算法)
(2)添加超時時間
5. python多線程的幾種方法
Python進階(二十六)-多線程實現同步的四種方式
臨界資源即那些一次只能被一個線程訪問的資源，典型例子就是列印機，它一次只能被一個程序用來執行列印功能，因為不能多個線程同時操作，而訪問這部分資源的代碼通常稱之為臨界區。
鎖機制
threading的Lock類，用該類的acquire函數進行加鎖，用realease函數進行解鎖
import threadingimport timeclass Num:
def __init__(self):
self.num = 0
self.lock = threading.Lock() def add(self):
self.lock.acquire()#加鎖，鎖住相應的資源
self.num += 1
num = self.num
self.lock.release()#解鎖，離開該資源
return num
n = Num()class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item def run(self):
time.sleep(2)
value = n.add()#將num加1，並輸出原來的數據和+1之後的數據
print(self.item,value)for item in range(5):
t = jdThread(item)
t.start()
t.join()#使線程一個一個執行
當一個線程調用鎖的acquire()方法獲得鎖時，鎖就進入「locked」狀態。每次只有一個線程可以獲得鎖。如果此時另一個線程試圖獲得這個鎖，該線程就會變為「blocked」狀態，稱為「同步阻塞」（參見多線程的基本概念）。
直到擁有鎖的線程調用鎖的release()方法釋放鎖之後，鎖進入「unlocked」狀態。線程調度程序從處於同步阻塞狀態的線程中選擇一個來獲得鎖，並使得該線程進入運行（running）狀態。
信號量
信號量也提供acquire方法和release方法，每當調用acquire方法的時候，如果內部計數器大於0，則將其減1，如果內部計數器等於0，則會阻塞該線程，知道有線程調用了release方法將內部計數器更新到大於1位置。
import threadingimport timeclass Num:
def __init__(self):
self.num = 0
self.sem = threading.Semaphore(value = 3) #允許最多三個線程同時訪問資源
def add(self):
self.sem.acquire()#內部計數器減1
self.num += 1
num = self.num
self.sem.release()#內部計數器加1
return num
n = Num()class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item def run(self):
time.sleep(2)
value = n.add()
print(self.item,value)for item in range(100):
6. python之多線程
進程的概念：以一個整體的形式暴露給操作系統管理，裡麵包含各種資源的調用。 對各種資源管理的集合就可以稱為進程。
線程的概念：是操作系統能夠進行運算調度的最小單位。本質上就是一串指令的集合。
進程和線程的區別：
1、線程共享內存空間，進程有獨立的內存空間。
2、線程啟動速度快，進程啟動速度慢。注意：二者的運行速度是無法比較的。
3、線程是執行的指令集，進程是資源的集合
4、兩個子進程之間數據不共享，完全獨立。同一個進程下的線程共享同一份數據。
5、創建新的線程很簡單，創建新的進程需要對他的父進程進行一次克隆。
6、一個線程可以操作（控制）同一進程里的其他線程，但是進程只能操作子進程
7、同一個進程的線程可以直接交流，兩個進程想要通信，必須通過一個中間代理來實現。
8、對於線程的修改，可能會影響到其他線程的行為。但是對於父進程的修改不會影響到子進程。
第一個程序，使用循環來創建線程，但是這個程序中一共有51個線程，我們創建了50個線程，但是還有一個程序本身的線程，是主線程。這51個線程是並行的。注意：這個程序中是主線程啟動了子線程。
相比上個程序，這個程序多了一步計算時間，但是我們觀察結果會發現，程序顯示的執行時間只有0.007秒，這是因為最後一個print函數它存在於主線程，而整個程序主線程和所有子線程是並行的，那麼可想而知，在子線程還沒有執行完畢的時候print函數就已經執行了，總的來說，這個時間只是執行了一個線程也就是主線程所用的時間。
接下來這個程序，吸取了上面這個程序的缺點，創建了一個列表，把所有的線程實例都存進去，然後使用一個for循環依次對線程實例調用join方法，這樣就可以使得主線程等待所創建的所有子線程執行完畢才能往下走。 注意實驗結果：和兩個線程的結果都是兩秒多一點
注意觀察實驗結果，並沒有執行列印task has done，並且程序執行時間極其短。
這是因為在主線程啟動子線程前把子線程設置為守護線程。
只要主線程執行完畢，不管子線程是否執行完畢，就結束。但是會等待非守護線程執行完畢
主線程退出，守護線程全部強制退出。皇帝死了，僕人也跟著殉葬
應用的場景 ： socket-server
注意：gil只是為了減低程序開發復雜度。但是在2.幾的版本上，需要加用戶態的鎖（gil的缺陷）而在3點幾的版本上，加鎖不加鎖都一樣。
下面這個程序是一個典型的生產者消費者模型。
生產者消費者模型是經典的在開發架構中使用的模型
運維中的集群就是生產者消費者模型，生活中很多都是
那麼，多線程的使用場景是什麼？
python中的多線程實質上是對上下文的不斷切換，可以說是假的多線程。而我們知道，io操作不佔用cpu，計算佔用cpu，那麼python的多線程適合io操作密集的任務，比如socket-server，那麼cpu密集型的任務，python怎麼處理？python可以折中的利用計算機的多核：啟動八個進程，每個進程有一個線程。這樣就可以利用多進程解決多核問題。
7. python基礎（21）-線程通信
到這里，我們要聊一下線程通信的內容；
首先，我們拋開語言不談，先看看比較基礎的東西，線程間通信的方式；其實也就是哪幾種（我這里說的，是我的所謂的知道的。。。）事件，消息隊列，信號量，條件變數（鎖算不算？我只是認為是同步的一種）；所以我們也就是要把這些掌握了，因為各有各的好處嘛；
條件變數我放到了上面的線程同步裡面講了，我總感覺這算是同步的一種，沒有很多具體信息的溝通；同時吧，我認為條件變數比較重要，因為這種可以應用於線程池的操作上；所以比較重要；這里，拋開條件變數不談，我們看看其他的東西；
1、消息隊列：
queue 模塊下提供了幾個阻塞隊列，這些隊列主要用於實現線程通信。在 queue 模塊下主要提供了三個類，分別代表三種隊列，它們的主要區別就在於進隊列、出隊列的不同。
關於這三個隊列類的簡單介紹如下：
queue.Queue(maxsize=0)：代表 FIFO（先進先出）的常規隊列，maxsize 可以限制隊列的大小。如果隊列的大小達到隊列的上限，就會加鎖，再次加入元素時就會被阻塞，直到隊列中的元素被消費。如果將 maxsize 設置為 0 或負數，則該隊列的大小就是無限制的。
queue.LifoQueue(maxsize=0)：代表 LIFO（後進先出）的隊列，與 Queue 的區別就是出隊列的順序不同。
PriorityQueue(maxsize=0)：代表優先順序隊列，優先順序最小的元素先出隊列。
這三個隊列類的屬性和方法基本相同， 它們都提供了如下屬性和方法：
Queue.qsize()：返回隊列的實際大小，也就是該隊列中包含幾個元素。
Queue.empty()：判斷隊列是否為空。
Queue.full()：判斷隊列是否已滿。
Queue.put(item, block=True, timeout=None)：向隊列中放入元素。如果隊列己滿，且 block 參數為 True（阻塞），當前線程被阻塞，timeout 指定阻塞時間，如果將 timeout 設置為 None，則代表一直阻塞，直到該隊列的元素被消費；如果隊列己滿，且 block 參數為 False（不阻塞），則直接引發 queue.FULL 異常。
Queue.put_nowait(item)：向隊列中放入元素，不阻塞。相當於在上一個方法中將 block 參數設置為 False。
Queue.get(item, block=True, timeout=None)：從隊列中取出元素（消費元素）。如果隊列已滿，且 block 參數為 True（阻塞），當前線程被阻塞，timeout 指定阻塞時間，如果將 timeout 設置為 None，則代表一直阻塞，直到有元素被放入隊列中； 如果隊列己空，且 block 參數為 False（不阻塞），則直接引發 queue.EMPTY 異常。
Queue.get_nowait(item)：從隊列中取出元素，不阻塞。相當於在上一個方法中將 block 參數設置為 False。
其實我們想想，這個隊列，是python進行封裝的，那麼我們可以用在線程間的通信；同時也是可以用做一個數據結構；先進先出就是隊列，後進先出就是棧；我們用這個棧寫個十進制轉二進制的例子：
沒毛病，可以正常的列印；其中需要注意的就是，maxsize在初始化的時候如果是0或者是個負數的話，那麼就會是不限制大小；
那麼其實我們想想，我們如果用做線程通信的話，我們兩個線程，可以把隊列設置為1的大小，如果是1對多，比如是創建者和消費者的關系，我們完全可以作為消息隊列，比如說創建者一直在創建一些東西，然後放入到消息隊列裡面，然後供消費著使用；就是一個很好的例子；所以，其實說是消息隊列，也就是隊列，沒差；
=====================================================================
下面來看一下事件
Event 是一種非常簡單的線程通信機制，一個線程發出一個 Event，另一個線程可通過該 Event 被觸發。
Event 本身管理一個內部旗標，程序可以通過 Event 的 set() 方法將該旗標設置為 True，也可以調用 clear() 方法將該旗標設置為 False。程序可以調用 wait() 方法來阻塞當前線程，直到 Event 的內部旗標被設置為 True。
Event 提供了如下方法：
is_set()：該方法返回 Event 的內部旗標是否為True。
set()：該方法將會把 Event 的內部旗標設置為 True，並喚醒所有處於等待狀態的線程。
clear()：該方法將 Event 的內部旗標設置為 False，通常接下來會調用 wait() 方法來阻塞當前線程。
wait(timeout=None)：該方法會阻塞當前線程。
這里我想解釋一下；其實對於事件來說，事件可以看成和條件變數是一樣的，只是我們說說不一樣的地方；
1、對於事件來說，一旦觸發了事件，也就是說，一旦set為true了，那麼就會一直為true，需要clear調內部的標志，才能繼續wait；但是conditon不是，他是一次性的喚醒其他線程；
2、conditon自己帶鎖；事件呢？不是的；沒有自己的鎖；比如說有一個存錢的線程，有一個是取錢的線程；那麼存錢的線程要存錢；需要怎麼辦呢？1、發現銀行沒有錢了（is_set判斷）；2、鎖住銀行；3、存錢；4、釋放銀行；5、喚醒事件；對於取錢的人；1、判斷是否有錢；2、被喚醒了，然後鎖住銀行；3、開始取錢；4、清理告訴存錢的人，我沒錢了（clear）；5、釋放鎖；6、等著錢存進去；
其實說白了，就是記住一點；這個旗標需要自己clear就對了
寫個例子，怕以後忘了怎麼用；
其實時間和信號量比較像；但是信號量不用自己清除標志位；但是事件是需要的；
8. python之多線程原理
並發：邏輯上具備同時處理多個任務的能力。
並行：物理上在同一時刻執行多個並發任務。
舉例：開個QQ，開了一個進程，開了微信，開了一個進程。在QQ這個進程裡面，傳輸文字開一個線程、傳輸語音開了一個線程、彈出對話框又開了一個線程。
總結：開一個軟體，相當於開了一個進程。在這個軟體運行的過程里，多個工作同時運轉，完成了QQ的運行，那麼這個多個工作分別有多個線程。
線程和進程之間的區別：
進程在python中的使用，對模塊threading進行操作，調用的這個三方庫。可以通過 help(threading) 了解其中的方法、變數使用情況。也可以使用 dir(threading) 查看目錄結構。
current_thread_num = threading.active_count() # 返回正在運行的線程數量
run_thread_len = len(threading.enumerate()) # 返回正在運行的線程數量
run_thread_list = threading.enumerate() # 返回當前運行線程的列表
t1=threading.Thread(target=dance) #創建兩個子線程，參數傳遞為函數名
t1.setDaemon(True) # 設置守護進程，守護進程：主線程結束時自動退出子線程。
t1.start() # 啟動子線程
t1.join() # 等待進程結束 exit()`# 主線程退出，t1子線程設置了守護進程，會自動退出。其他子線程會繼續執行。
9. Python如何實現並行的多線程
Python中使用線程有兩種方式：函數或者用類來包裝線程對象。函數式：調用thread模塊中的start_new_thread()函數來產生新線程。線程模塊:Python通過兩個標准庫thread和threading提供對線程的支持。