python中的線程與線程池,什麼是線程池

本文目錄一覽：

• 1、Python中的線程池是什麼
• 2、python基礎（21）-線程通信
• 3、小白都看懂了，Python 中的線程和進程精講，建議收藏
• 4、python 多線程爬取網站數據利用線程池
• 5、python如何實現線程池
• 6、Python多線程總結

Python中的線程池是什麼

線程，有時被稱為輕量級進程(Lightweight Process，LWP），是程序執行流的最小單元。一個標準的線程由線程ID，當前指令指針(PC），寄存器集合和堆棧組成。另外，線程是進程中的一個實體，是被系統獨立調度和分派的基本單位，線程自己不擁有系統資源，只擁有一點兒在運行中必不可少的資源，但它可與同屬一個進程的其它線程共享進程所擁有的全部資源。一個線程可以創建和撤消另一個線程，同一進程中的多個線程之間可以並發執行。由於線程之間的相互制約，致使線程在運行中呈現出間斷性。線程也有就緒、阻塞和運行三種基本狀態。就緒狀態是指線程具備運行的所有條件，邏輯上可以運行，在等待處理機；運行狀態是指線程佔有處理機正在運行；阻塞狀態是指線程在等待一個事件（如某個信號量），邏輯上不可執行。每一個程序都至少有一個線程，若程序只有一個線程，那就是程序本身。

線程是程序中一個單一的順序控制流程。進程內有一個相對獨立的、可調度的執行單元，是系統獨立調度和分派CPU的基本單位指令運行時的程序的調度單位。在單個程序中同時運行多個線程完成不同的工作，稱為多線程。

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就對了

寫個例子，怕以後忘了怎麼用；

其實時間和信號量比較像；但是信號量不用自己清除標誌位；但是事件是需要的；

小白都看懂了，Python 中的線程和進程精講，建議收藏

目錄

眾所周知，CPU是計算機的核心，它承擔了所有的計算任務。而操作系統是計算機的管理者，是一個大管家，它負責任務的調度，資源的分配和管理，統領整個計算機硬件。應用程序是具有某種功能的程序，程序運行與操作系統之上

在很早的時候計算機並沒有線程這個概念，但是隨着時代的發展，只用進程來處理程序出現很多的不足。如當一個進程堵塞時，整個程序會停止在堵塞處，並且如果頻繁的切換進程，會浪費系統資源。所以線程出現了

線程是能擁有資源和獨立運行的最小單位，也是程序執行的最小單位。一個進程可以擁有多個線程，而且屬於同一個進程的多個線程間會共享該進行的資源

① 200 多本 Python 電子書（和經典的書籍）應該有

② Python標準庫資料（最全中文版）

③ 項目源碼（四五十個有趣且可靠的練手項目及源碼）

④ Python基礎入門、爬蟲、網絡開發、大數據分析方面的視頻（適合小白學習）

⑤ Python學習路線圖（告別不入流的學習）

私信我01即可獲取大量Python學習資源

進程時一個具有一定功能的程序在一個數據集上的一次動態執行過程。進程由程序，數據集合和進程控制塊三部分組成。程序用於描述進程要完成的功能，是控制進程執行的指令集；數據集合是程序在執行時需要的數據和工作區；程序控制塊（PCB）包含程序的描述信息和控制信息，是進程存在的唯一標誌

在Python中，通過兩個標準庫 thread 和 Threading 提供對線程的支持, threading 對 thread 進行了封裝。 threading 模塊中提供了 Thread , Lock , RLOCK , Condition 等組件

在Python中線程和進程的使用就是通過 Thread 這個類。這個類在我們的 thread 和 threading 模塊中。我們一般通過 threading 導入

默認情況下，只要在解釋器中，如果沒有報錯，則說明線程可用

守護模式：

現在我們程序代碼中，有多個線程， 並且在這個幾個線程中都會去 操作同一部分內容，那麼如何實現這些數據的共享呢？

這時，可以使用 threading庫裡面的鎖對象 Lock 去保護

Lock 對象的acquire方法 是申請鎖

每個線程在操作共享數據對象之前，都應該申請獲取操作權，也就是調用該共享數據對象對應的鎖對象的acquire方法，如果線程A 執行了 acquire() 方法，別的線程B 已經申請到了這個鎖， 並且還沒有釋放，那麼 線程A的代碼就在此處 等待 線程B 釋放鎖，不去執行後面的代碼。

直到線程B 執行了鎖的 release 方法釋放了這個鎖， 線程A 才可以獲取這個鎖，就可以執行下面的代碼了

如：

到在使用多線程時，如果數據出現和自己預期不符的問題，就可以考慮是否是共享的數據被調用覆蓋的問題

使用 threading 庫裡面的鎖對象 Lock 去保護

Python中的多進程是通過multiprocessing包來實現的，和多線程的threading.Thread差不多，它可以利用multiprocessing.Process對象來創建一個進程對象。這個進程對象的方法和線程對象的方法差不多也有start(), run(), join()等方法，其中有一個方法不同Thread線程對象中的守護線程方法是setDeamon，而Process進程對象的守護進程是通過設置daemon屬性來完成的

守護模式：

其使用方法和線程的那個 Lock 使用方法類似

Manager的作用是提供多進程共享的全局變量，Manager()方法會返回一個對象，該對象控制着一個服務進程，該進程中保存的對象運行其他進程使用代理進行操作

語法：

線程池的基類是 concurrent.futures 模塊中的 Executor ， Executor 提供了兩個子類，即 ThreadPoolExecutor 和 ProcessPoolExecutor ，其中 ThreadPoolExecutor 用於創建線程池，而 ProcessPoolExecutor 用於創建進程池

如果使用線程池/進程池來管理並發編程，那麼只要將相應的 task 函數提交給線程池/進程池，剩下的事情就由線程池/進程池來搞定

Exectuor 提供了如下常用方法：

程序將 task 函數提交（submit）給線程池後，submit 方法會返回一個 Future 對象，Future 類主要用於獲取線程任務函數的返回值。由於線程任務會在新線程中以異步方式執行，因此，線程執行的函數相當於一個“將來完成”的任務，所以 Python 使用 Future 來代表

Future 提供了如下方法：

使用線程池來執行線程任務的步驟如下：

最佳線程數目 = （（線程等待時間+線程CPU時間）/線程CPU時間 ）* CPU數目

也可以低於 CPU 核心數

使用線程池來執行線程任務的步驟如下：

關於進程的開啟代碼一定要放在 if __name__ == ‘__main__’: 代碼之下，不能放到函數中或其他地方

開啟進程的技巧

開啟進程的數量最好低於最大 CPU 核心數

python 多線程爬取網站數據利用線程池

“””

@author: wangxingchun

多線程（線程池）

下載數據

“””

import requests

import csv

from concurrent.futures import ThreadPoolExecutor as tp

#創建一個csv文件，注意創建writer對象”csv.writer()”

f = open(‘xinfadi.csv’,’w’,encoding=’utf8′)

csvwrite = csv.writer(f)

#如果寫入txt文件，不需要創建writer對象。

# f = open(‘xinfadidata.txt’,’w’,encoding=’utf8′)

#創建一個函數，以頁碼做為參數

def down(n_page):

url = ”

data = {‘count’: 428225,’current’: n_page,’limit’: 20}

resp = requests.post(url,data=data)

datas =resp.json()

#通過分析數據嵌套情況，獲取數據。此處可在網頁開發工具json數據中查看分析。

for i in range(len(datas[‘list’])):

name = datas[‘list’][i][‘prodName’]

highPrice = datas[‘list’][i][‘highPrice’]

lowPrice = datas[‘list’][i][‘lowPrice’]

pubDate = datas[‘list’][i][‘pubDate’]

place = datas[‘list’][i][‘place’]

csvwrite.writerow((name,highPrice,lowPrice,pubDate,place))#writerow要求寫入的是可迭代對象

# f.writelines(f'{name},{highPrice},{lowPrice},{pubDate},{place} ‘)

resp.close()

if __name__ == ‘__main__’:

with tp(50) as t: #創建線程池，

for n in range(1,101): #遍曆數據網頁

t.submit(down,n) #提交給線程池，進行多線程下載

print(f’共{n}頁數據下載完畢!’)

f.close()

python如何實現線程池

#這個類是線程類，用來在主程序中調用生成一個線程。其實線程池就是線程的集合地，

#能夠解決有效統一的管理線程，基本就達到了線程池的目的；

#這一段代碼是我的爬蟲程序中的一部分，希望對你有用。

class Spider(Thread):

    def __init__(self, todo_list):

        super().__init__()

        self.setDaemon(True)

        self.todo_list = todo_list

        self.stat = IDLE

    def is_idle(self):

        return self.stat == IDLE

    def run(self):

        while True:

            url = self.todo_list.get()

            # 開始線程工作

#這個函數就是主函數了，            

def main(max_threads):

    ########這裡和上一個函數就是核心代碼了。

    # 創建 N 個線程，並啟動

    print(‘Spawn spiders’)

    spiders = [Spider(todo_list) for i in range(max_threads)]

    for spd in spiders:

        spd.start()

#python主運行代碼：            

if __name__ == ‘__main__’:

        main(max_threads)

只能給你這麼多解釋了，如果想弄懂，還是要去看看基礎知識的。

另外可以查一下有沒有封裝好的三方庫。

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