Python 多進程與多線程

Python 多進程與多線程

來自專欄 極客猴

前言：為什麼有人說 Python 的多線程是雞肋，不是真正意義上的多線程？

看到這裡，也許你會疑惑。這很正常，所以讓我們帶著問題來閱讀本文章吧。

問題：

1、Python 多線程為什麼耗時更長？

2、為什麼在 Python 裡面推薦使用多進程而不是多線程？

1 基礎知識

現在的 PC 都是多核的，使用多線程能充分利用 CPU 來提供程序的執行效率。

1.1 線程

線程是一個基本的 CPU 執行單元。它必須依託於進程存活。一個線程是一個execution context（執行上下文），即一個 CPU 執行時所需要的一串指令。

1.2 進程

進程是指一個程序在給定數據集合上的一次執行過程，是系統進行資源分配和運行調用的獨立單位。可以簡單地理解為操作系統中正在執行的程序。也就說，每個應用程序都有一個自己的進程。

每一個進程啟動時都會最先產生一個線程，即主線程。然後主線程會再創建其他的子線程。

1.3 兩者的區別

• 線程必須在某個進行中執行。
• 一個進程可包含多個線程，其中有且只有一個主線程。
• 多線程共享同個地址空間、打開的文件以及其他資源。
• 多進程共享物理內存、磁碟、印表機以及其他資源。

1.4 線程的類型

線程的因作用可以劃分為不同的類型。大致可分為：

• 主線程
• 子線程
• 守護線程（後台線程）
• 前台線程

2 Python 多線程

2.1 GIL

其他語言，CPU 是多核時是支持多個線程同時執行。但在 Python 中，無論是單核還是多核，同時只能由一個線程在執行。其根源是 GIL 的存在。

GIL 的全稱是 Global Interpreter Lock(全局解釋器鎖)，來源是 Python 設計之初的考慮，為了數據安全所做的決定。某個線程想要執行，必須先拿到 GIL，我們可以把 GIL 看作是「通行證」，並且在一個 Python 進程中，GIL 只有一個。拿不到通行證的線程，就不允許進入 CPU 執行。

而目前 Python 的解釋器有多種，例如：

• CPython：CPython 是用C語言實現的 Python 解釋器。 作為官方實現，它是最廣泛使用的 Python 解釋器。
• PyPy：PyPy 是用RPython實現的解釋器。RPython 是 Python 的子集， 具有靜態類型。這個解釋器的特點是即時編譯，支持多重後端（C, CLI, JVM）。PyPy 旨在提高性能，同時保持最大兼容性（參考 CPython 的實現）。
• Jython：Jython 是一個將 Python 代碼編譯成 Java 位元組碼的實現，運行在JVM (Java Virtual Machine) 上。另外，它可以像是用 Python 模塊一樣，導入 並使用任何Java類。
• IronPython：IronPython 是一個針對 .NET 框架的 Python 實現。它 可以用 Python 和 .NET framewor k的庫，也能將 Python 代碼暴露給 .NET 框架中的其他語言。

GIL 只在 CPython 中才有，而在 PyPy 和 Jython 中是沒有 GIL 的。

每次釋放 GIL鎖，線程進行鎖競爭、切換線程，會消耗資源。這就導致列印線程執行時長，會發現耗時更長的原因。

並且由於 GIL 鎖存在，Python 里一個進程永遠只能同時執行一個線程(拿到 GIL 的線程才能執行)，這就是為什麼在多核CPU上，Python 的多線程效率並不高的根本原因。

2.2 創建多線程

Python提供兩個模塊進行多線程的操作，分別是thread和threading，

前者是比較低級的模塊，用於更底層的操作，一般應用級別的開發不常用。

• 方法1：直接使用threading.Thread()

import threading# 這個函數名可隨便定義def run(n): print("current task：", n)if __name__ == "__main__": t1 = threading.Thread(target=run, args=("thread 1",)) t2 = threading.Thread(target=run, args=("thread 2",)) t1.start() t2.start()

• 方法2：繼承threading.Thread來自定義線程類，重寫run方法

import threadingclass MyThread(threading.Thread): def __init__(self, n): super(MyThread, self).__init__() # 重構run函數必須要寫 self.n = n def run(self): print("current task：", n)if __name__ == "__main__": t1 = MyThread("thread 1") t2 = MyThread("thread 2") t1.start() t2.start()

2.3 線程合併

Join函數執行順序是逐個執行每個線程，執行完畢後繼續往下執行。主線程結束後，子線程還在運行，join函數使得主線程等到子線程結束時才退出。

import threadingdef count(n): while n > 0: n -= 1if __name__ == "__main__": t1 = threading.Thread(target=count, args=("100000",)) t2 = threading.Thread(target=count, args=("100000",)) t1.start() t2.start() # 將 t1 和 t2 加入到主線程中 t1.join() t2.join()

2.4 線程同步與互斥鎖

線程之間數據共享的。當多個線程對某一個共享數據進行操作時，就需要考慮到線程安全問題。threading模塊中定義了Lock 類，提供了互斥鎖的功能來保證多線程情況下數據的正確性。

用法的基本步驟：

#創建鎖mutex = threading.Lock()#鎖定mutex.acquire([timeout])#釋放mutex.release()

其中，鎖定方法acquire可以有一個超時時間的可選參數timeout。如果設定了timeout，則在超時後通過返回值可以判斷是否得到了鎖，從而可以進行一些其他的處理。

具體用法見示例代碼：

import threadingimport timenum = 0mutex = threading.Lock()class MyThread(threading.Thread): def run(self): global num time.sleep(1) if mutex.acquire(1): num = num + 1 msg = self.name + : num value is + str(num) print(msg) mutex.release()if __name__ == __main__: for i in range(5): t = MyThread() t.start()

2.5 可重入鎖（遞歸鎖）

為了滿足在同一線程中多次請求同一資源的需求，Python 提供了可重入鎖（RLock）。

RLock內部維護著一個Lock和一個counter變數，counter 記錄了 acquire 的次數，從而使得資源可以被多次 require。直到一個線程所有的 acquire 都被 release，其他的線程才能獲得資源。

具體用法如下：

#創建 RLockmutex = threading.RLock()class MyThread(threading.Thread): def run(self): if mutex.acquire(1): print("thread " + self.name + " get mutex") time.sleep(1) mutex.acquire() mutex.release() mutex.release()

2.6 守護線程

如果希望主線程執行完畢之後，不管子線程是否執行完畢都隨著主線程一起結束。我們可以使用setDaemon(bool)函數，它跟join函數是相反的。它的作用是設置子線程是否隨主線程一起結束，必須在start() 之前調用，默認為False。

2.7 定時器

如果需要規定函數在多少秒後執行某個操作，需要用到Timer類。具體用法如下：

from threading import Timerdef show(): print("Pyhton")# 指定一秒鐘之後執行 show 函數t = Timer(1, hello)t.start()

3 Python 多進程

3.1 創建多進程

Python 要進行多進程操作，需要用到muiltprocessing庫，其中的Process類跟threading模塊的Thread類很相似。所以直接看代碼熟悉多進程。

• 方法1：直接使用Process, 代碼如下：

from multiprocessing import Process def show(name): print("Process name is " + name)if __name__ == "__main__": proc = Process(target=show, args=(subprocess,)) proc.start() proc.join()

• 方法2：繼承Process來自定義進程類，重寫run方法, 代碼如下：

from multiprocessing import Processimport timeclass MyProcess(Process): def __init__(self, name): super(MyProcess, self).__init__() self.name = name def run(self): print(process name : + str(self.name)) time.sleep(1)if __name__ == __main__: for i in range(3): p = MyProcess(i) p.start() for i in range(3): p.join()

3.2 多進程通信

進程之間不共享數據的。如果進程之間需要進行通信，則要用到Queue模塊或者Pipi模塊來實現。

• Queue

Queue 是多進程安全的隊列，可以實現多進程之間的數據傳遞。它主要有兩個函數,put和get。

put() 用以插入數據到隊列中，put 還有兩個可選參數：blocked 和 timeout。如果 blocked 為 True（默認值），並且 timeout 為正值，該方法會阻塞 timeout 指定的時間，直到該隊列有剩餘的空間。如果超時，會拋出 Queue.Full 異常。如果 blocked 為 False，但該 Queue 已滿，會立即拋出 Queue.Full 異常。

get()可以從隊列讀取並且刪除一個元素。同樣，get 有兩個可選參數：blocked 和 timeout。如果 blocked 為 True（默認值），並且 timeout 為正值，那麼在等待時間內沒有取到任何元素，會拋出 Queue.Empty 異常。如果blocked 為 False，有兩種情況存在，如果 Queue 有一個值可用，則立即返回該值，否則，如果隊列為空，則立即拋出 Queue.Empty 異常。

具體用法如下：

from multiprocessing import Process, Queuedef put(queue): queue.put(Queue 用法)if __name__ == __main__: queue = Queue() pro = Process(target=put, args=(queue,)) pro.start() print(queue.get()) pro.join()

• Pipe

Pipe的本質是進程之間的用管道數據傳遞，而不是數據共享，這和socket有點像。pipe() 返回兩個連接對象分別表示管道的兩端，每端都有send() 和recv()函數。

如果兩個進程試圖在同一時間的同一端進行讀取和寫入那麼，這可能會損壞管道中的數據。

具體用法如下：

from multiprocessing import Process, Pipedef show(conn): conn.send(Pipe 用法) conn.close()if __name__ == __main__: parent_conn, child_conn = Pipe() pro = Process(target=show, args=(child_conn,)) pro.start() print(parent_conn.recv()) pro.join()

3.3 進程池

創建多個進程，我們不用傻傻地一個個去創建。我們可以使用Pool模塊來搞定。

Pool 常用的方法如下：

方法含義apply()同步執行（串列）apply_async()非同步執行（並行）terminate()立刻關閉進程池join()主進程等待所有子進程執行完畢。必須在close或terminate()之後使用close()等待所有進程結束後，才關閉進程池

具體用法見示例代碼：

from multiprocessing import Pooldef show(num): print(num : + str(num))if __name__=="__main__": pool = Pool(processes = 3) for i in xrange(6): # 維持執行的進程總數為processes，當一個進程執行完畢後會添加新的進程進去 pool.apply_async(show, args=(i, )) print(====== apply_async ======) pool.close() #調用join之前，先調用close函數，否則會出錯。執行完close後不會有新的進程加入到pool,join函數等待所有子進程結束 pool.join()

4 選擇多線程還是多進程？

在這個問題上，首先要看下你的程序是屬於哪種類型的。一般分為兩種 CPU 密集型 和 I/O 密集型。

• CPU 密集型：程序比較偏重於計算，需要經常使用 CPU 來運算。例如科學計算的程序，機器學習的程序等。
• I/O 密集型：顧名思義就是程序需要頻繁進行輸入輸出操作。爬蟲程序就是典型的 I/O 密集型程序。

如果程序是屬於 CPU 密集型，建議使用多進程。而多線程就更適合應用於 I/O 密集型程序。

本文原創發佈於微信公眾號「極客猴」，歡迎關注第一時間獲取更多原創分享

推薦閱讀：