前言：為什么有人說 Python 的多線程是雞肋，不是真正意義上的多線程？
看到這里，也許你會疑惑。這很正常，所以讓我們帶著問題來閱讀本文章吧。
問題：
1、Python 多線程為什么耗時更長？
2、為什么在 Python 里面推薦使用多進程而不是多線程？
1 基礎知識
現在的 PC 都是多核的，使用多線程能充分利用 CPU 來提供程序的執行效率。
1.1 線程
線程是一個基本的 CPU 執行單元。它必須依托于進程存活。一個線程是一個execution context（執行上下文），即一個 CPU 執行時所需要的一串指令。
1.2 進程
進程是指一個程序在給定數據集合上的一次執行過程，是系統進行資源分配和運行調用的獨立單位?？梢院唵蔚乩斫鉃椴僮飨到y中正在執行的程序。也就說，每個應用程序都有一個自己的進程。
每一個進程啟動時都會最先產生一個線程，即主線程。然后主線程會再創建其他的子線程。
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 threading
class 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 threading
def count(n):
while n > 0:
n -= 1
if __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 threading
import time
num = 0
mutex = 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，其他的線程才能獲得資源。
具體用法如下：
#創建 RLock
mutex = 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 Timer
def 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 Process
import time
class 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, Queue
def 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, Pipe
def 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 Pool
def 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 密集型程序。
上篇文章：爬蟲實戰一：爬取當當網所有 Python 書籍
推薦閱讀：內容提取神器 beautiful Soup 的用法
