python數據同時給多個線程

python多線程

有很多的場景中的事情是同時進行的,比如開車的時候,手和腳共同來駕駛汽車,再比如唱歌跳舞也是同時進行的

結果:

?_thread

?threading(推薦使用)

結果:

threading.enumerate()可查看當前正在運行的線程

結果:

結果:

結果:

結果:出現資源競爭導致計算結果不正確

(1)當多個線程幾乎同時修改某一個共享數據的時候,需要進行同步控制

(2)線程同步能夠保證多個線程安全訪問資源,最簡單的同步機制是引入互斥鎖

(3)互斥鎖為資源引入一個狀態:鎖定/非鎖定

(4)某個線程要更愛共享數據時,先將其鎖定,此時資源的狀態為"鎖定",其他線程不能更改;直到該線程釋放資源,將資源狀態變為"非鎖定"

(5)互斥鎖保證了每次只有一個線程進行寫入操作,從而保證了多線程情況下數據的正確性

結果:計算正確

結果:卡住了

在線程間共享多個資源的時候,如果兩個線程分別戰友一部分資源且同時等待對方資源,就會造成死鎖

(1)程序設計時避免(銀行家演算法)

(2)添加超時時間

多線程的目的-「最大限度地利用CPU資源」。每個程序執行時都會產生一個進程，而每一個進程至少要有一個主線程。對於單CPU來說（沒有開啟超線程），在同一時間只能執行一個線程，所以如果想實現多任務，那麼就只能每個進程或線程獲得一個時間片，在某個時間片內，只能一個線程執行，然後按照某種策略換其他線程執行。由於時間片很短，這樣給用戶的感覺是同時有好多線程在執行。

Python是運行在解釋器中的語言，查找資料知道，python中有一個全局鎖（GIL），在使用多線程(Thread)的情況下，不能發揮多核的優勢。而使用多進程(Multiprocess)，則可以發揮多核的優勢真正地提高效率。

單線程、多線程和多進程的效率對比測試：github地址

資料顯示，如果多線程的進程是CPU密集型的，那多線程並不能有多少效率上的提升，相反還可能會因為線程的頻繁切換，導致效率下降，推薦使用多進程；如果是IO密集型，多線程進程可以利用IO阻塞等待時的空閑時間執行其他線程，提升效率。所以我們根據實驗對比不同場景的效率

|CPU密集型操作|IO密集型操作|網路請求密集型操作

--|--|--|--

線性操作|69.73533328374|17.76633326213|6.78833333651

多線程操作|75.40299995740|145.68366670609|1.93999997775

多進程操作|13.97433336576|4.67833328247|2.38333328565

僅個人觀點，，歡迎留言~~~

使用線程池可以有效地控制系統中並發線程的數量。當系統中包含有大量的並發線程時，會導致系統性能急劇下降，甚至導致Python解釋器崩潰，而線程池的最大線程數參數可以控制系統中並發線程的數量不超過此數。

進程的概念：以一個整體的形式暴露給操作系統管理，裡麵包含各種資源的調用。對各種資源管理的集合就可以稱為進程。

線程的概念：是操作系統能夠進行運算調度的最小單位。本質上就是一串指令的集合。

進程和線程的區別：

1、線程共享內存空間，進程有獨立的內存空間。

2、線程啟動速度快，進程啟動速度慢。注意：二者的運行速度是無法比較的。

3、線程是執行的指令集，進程是資源的集合

4、兩個子進程之間數據不共享，完全獨立。同一個進程下的線程共享同一份數據。

5、創建新的線程很簡單，創建新的進程需要對他的父進程進行一次克隆。

6、一個線程可以操作（控制）同一進程里的其他線程，但是進程只能操作子進程

7、同一個進程的線程可以直接交流，兩個進程想要通信，必須通過一個中間代理來實現。

8、對於線程的修改，可能會影響到其他線程的行為。但是對於父進程的修改不會影響到子進程。

第一個程序，使用循環來創建線程，但是這個程序中一共有51個線程，我們創建了50個線程，但是還有一個程序本身的線程，是主線程。這51個線程是並行的。注意：這個程序中是主線程啟動了子線程。

相比上個程序，這個程序多了一步計算時間，但是我們觀察結果會發現，程序顯示的執行時間只有0.007秒，這是因為最後一個print函數它存在於主線程，而整個程序主線程和所有子線程是並行的，那麼可想而知，在子線程還沒有執行完畢的時候print函數就已經執行了，總的來說，這個時間只是執行了一個線程也就是主線程所用的時間。

接下來這個程序，吸取了上面這個程序的缺點，創建了一個列表，把所有的線程實例都存進去，然後使用一個for循環依次對線程實例調用join方法，這樣就可以使得主線程等待所創建的所有子線程執行完畢才能往下走。注意實驗結果：和兩個線程的結果都是兩秒多一點

注意觀察實驗結果，並沒有執行列印taskhasdone，並且程序執行時間極其短。

這是因為在主線程啟動子線程前把子線程設置為守護線程。

只要主線程執行完畢，不管子線程是否執行完畢，就結束。但是會等待非守護線程執行完畢

主線程退出，守護線程全部強制退出。皇帝死了，僕人也跟著殉葬

應用的場景：socket-server

注意：gil只是為了減低程序開發復雜度。但是在2.幾的版本上，需要加用戶態的鎖（gil的缺陷）而在3點幾的版本上，加鎖不加鎖都一樣。

下面這個程序是一個典型的生產者消費者模型。

生產者消費者模型是經典的在開發架構中使用的模型

運維中的集群就是生產者消費者模型，生活中很多都是

那麼，多線程的使用場景是什麼？

python中的多線程實質上是對上下文的不斷切換，可以說是假的多線程。而我們知道，io操作不佔用cpu，計算佔用cpu，那麼python的多線程適合io操作密集的任務，比如socket-server，那麼cpu密集型的任務，python怎麼處理？python可以折中的利用計算機的多核：啟動八個進程，每個進程有一個線程。這樣就可以利用多進程解決多核問題。

結語：以上就是首席CTO筆記為大家整理的關於python最多多少線程的相關內容解答匯總了，希望對您有所幫助！如果解決了您的問題歡迎分享給更多關注此問題的朋友喔～

2. 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):

3. 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 只能由本線程進行操作。