Python多程序與多執行緒程式設計及GIL詳解

阿新 • • 發佈：2019-07-19

介紹如何使用python的multiprocess和threading模組進行多執行緒和多程序程式設計。

Python的多程序程式設計與multiprocess模組

python的多程序程式設計主要依靠multiprocess模組。我們先對比兩段程式碼，看看多程序程式設計的優勢。我們模擬了一個非常耗時的任務，計算8的20次方，為了使這個任務顯得更耗時，我們還讓它sleep 2秒。第一段程式碼是單程序計算(程式碼如下所示)，我們按順序執行程式碼，重複計算2次，並打印出總共耗時。

import time
import os
def long_time_task():
    print('當前程序: {}'.format(os.getpid()))
    time.sleep(2)
    print("結果: {}".format(8 ** 20))

if __name__ == "__main__":
    print('當前母程序: {}'.format(os.getpid()))
    start = time.time()
    for i in range(2):
        long_time_task()

    end = time.time()
    print("用時{}秒".format((end-start)))

輸出結果如下，總共耗時4秒，至始至終只有一個程序14236。看來電腦計算8的20次方基本不費時。

當前母程序: 14236
當前程序: 14236
結果: 1152921504606846976
當前程序: 14236
結果: 1152921504606846976
用時4.01080060005188秒

第2段程式碼是多程序計算程式碼。我們利用multiprocess模組的Process方法建立了兩個新的程序p1和p2來進行平行計算。Process方法接收兩個引數, 第一個是target，一般指向函式名，第二個時args，需要向函式傳遞的引數。對於建立的新程序，呼叫start()方法即可讓其開始。我們可以使用os.getpid()打印出當前程序的名字。

from multiprocessing import Process
import os
import time
def long_time_task(i):
    print('子程序: {} - 任務{}'.format(os.getpid(), i))
    time.sleep(2)
    print("結果: {}".format(8 ** 20))
if __name__=='__main__':
    print('當前母程序: {}'.format(os.getpid()))
    start = time.time()
    p1 = Process(target=long_time_task, args=(1,))
    p2 = Process(target=long_time_task, args=(2,))
    print('等待所有子程序完成。')
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    end = time.time()
    print("總共用時{}秒".format((end - start)))

輸出結果如下所示，耗時變為2秒，時間減了一半，可見併發執行的時間明顯比順序執行要快很多。你還可以看到儘管我們只建立了兩個程序，可實際執行中卻包含裡1個母程序和2個子程序。之所以我們使用join()方法就是為了讓母程序阻塞，等待子程序都完成後才打印出總共耗時，否則輸出時間只是母程序執行的時間。

當前母程序: 6920
等待所有子程序完成。
子程序: 17020 - 任務1
子程序: 5904 - 任務2
結果: 1152921504606846976
結果: 1152921504606846976
總共用時2.131091356277466秒

知識點:

新建立的程序與程序的切換都是要耗資源的，所以平時工作中程序數不能開太大。
同時可以執行的程序數一般受制於CPU的核數。
除了使用Process方法，我們還可以使用Pool類建立多程序。

利用multiprocess模組的Pool類建立多程序

很多時候系統都需要建立多個程序以提高CPU的利用率，當數量較少時，可以手動生成一個個Process例項。當程序數量很多時，或許可以利用迴圈，但是這需要程式設計師手動管理系統中併發程序的數量，有時會很麻煩。這時程序池Pool就可以發揮其功效了。可以通過傳遞引數限制併發程序的數量，預設值為CPU的核數。

Pool類可以提供指定數量的程序供使用者呼叫，當有新的請求提交到Pool中時，如果程序池還沒有滿，就會建立一個新的程序來執行請求。如果池滿，請求就會告知先等待，直到池中有程序結束，才會建立新的程序來執行這些請求。

下面介紹一下multiprocessing 模組下的Pool類的幾個方法：

1.apply_async

函式原型：apply_async(func[, args=()[, kwds={}[, callback=None]]])

其作用是向程序池提交需要執行的函式及引數，各個程序採用非阻塞（非同步）的呼叫方式，即每個子程序只管執行自己的，不管其它程序是否已經完成。

2.map()

函式原型：map(func, iterable[, chunksize=None])

Pool類中的map方法，與內建的map函式用法行為基本一致，它會使程序阻塞直到結果返回。注意：雖然第二個引數是一個迭代器，但在實際使用中，必須在整個佇列都就緒後，程式才會執行子程序。

3.map_async()

函式原型：map_async(func, iterable[, chunksize[, callback]])
與map用法一致，但是它是非阻塞的。其有關事項見apply_async。

4.close()

關閉程序池（pool），使其不在接受新的任務。

5. terminate()

結束工作程序，不在處理未處理的任務。

6.join()

主程序阻塞等待子程序的退出， join方法要在close或terminate之後使用。

下例是一個簡單的multiprocessing.Pool類的例項。因為小編我的CPU是4核的，一次最多可以同時執行4個程序，所以我開啟了一個容量為4的程序池。4個程序需要計算5次，你可以想象4個程序並行4次計算任務後，還剩一次計算任務(任務4)沒有完成，系統會等待4個程序完成後重新安排一個程序來計算。

from multiprocessing import Pool, cpu_count
import os
import time
def long_time_task(i):
    print('子程序: {} - 任務{}'.format(os.getpid(), i))
    time.sleep(2)
    print("結果: {}".format(8 ** 20))
if __name__=='__main__':
    print("CPU核心數:{}".format(cpu_count()))
    print('當前母程序: {}'.format(os.getpid()))
    start = time.time()
    p = Pool(4)
    for i in range(5):
        p.apply_async(long_time_task, args=(i,))
    print('等待所有子程序完成。')
    p.close()
    p.join()
    end = time.time()
    print("總共用時{}秒".format((end - start)))

知識點:

對Pool物件呼叫join()方法會等待所有子程序執行完畢，呼叫join()之前必須先呼叫close()或terminate()方法，讓其不再接受新的Process了。

輸出結果如下所示，5個任務（每個任務大約耗時2秒)使用多程序平行計算只需4.37秒,, 耗時減少了60%。

CPU核心數:4
當前母程序: 2556
等待所有子程序完成。
子程序: 16480 - 任務0
子程序: 15216 - 任務1
子程序: 15764 - 任務2
子程序: 10176 - 任務3
結果: 1152921504606846976
結果: 1152921504606846976
子程序: 15216 - 任務4
結果: 1152921504606846976
結果: 1152921504606846976
結果: 1152921504606846976
總共用時4.377134561538696秒

相信大家都知道python直譯器中存在GIL(全域性直譯器鎖), 它的作用就是保證同一時刻只有一個執行緒可以執行程式碼。由於GIL的存在，很多人認為python中的多執行緒其實並不是真正的多執行緒，如果想要充分地使用多核CPU的資源，在python中大部分情況需要使用多程序。然而這並意味著python多執行緒程式設計沒有意義哦，請繼續閱讀下文。

多程序間的資料共享與通訊

通常，程序之間是相互獨立的，每個程序都有獨立的記憶體。通過共享記憶體(nmap模組)，程序之間可以共享物件，使多個程序可以訪問同一個變數(地址相同，變數名可能不同)。多程序共享資源必然會導致程序間相互競爭，所以應該盡最大可能防止使用共享狀態。還有一種方式就是使用佇列queue來實現不同程序間的通訊或資料共享，這一點和多執行緒程式設計類似。

from multiprocessing import Process, Queue
import os, time, random
# 寫資料程序執行的程式碼:
def write(q):
    print('Process to write: {}'.format(os.getpid()))
    for value in ['A', 'B', 'C']:
        print('Put %s to queue...' % value)
        q.put(value)
        time.sleep(random.random())
# 讀資料程序執行的程式碼:
def read(q):
    print('Process to read:{}'.format(os.getpid()))
    while True:
        value = q.get(True)
        print('Get %s from queue.' % value)
if __name__=='__main__':
    # 父程序建立Queue，並傳給各個子程序：
   q = Queue()
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))
    # 啟動子程序pw，寫入:
    pw.start()
    # 啟動子程序pr，讀取:
    pr.start()
    # 等待pw結束:
    pw.join()
    # pr程序裡是死迴圈，無法等待其結束，只能強行終止:
    pr.terminate()

下例這段程式碼中中建立了2個獨立程序，一個負責寫(pw), 一個負責讀(pr), 實現了共享一個佇列queue。

輸出結果如下所示:

Process to write: 3036
Put A to queue...
Process to read:9408
Get A from queue.
Put B to queue...
Get B from queue.
Put C to queue...
Get C from queue.

Python的多執行緒程式設計與threading模組

python 3中的多程序程式設計主要依靠threading模組。建立新執行緒與建立新程序的方法非常類似。threading.Thread方法可以接收兩個引數, 第一個是target，一般指向函式名，第二個時args，需要向函式傳遞的引數。對於建立的新執行緒，呼叫start()方法即可讓其開始。我們還可以使用current_thread().name打印出當前執行緒的名字。下例中我們使用多執行緒技術重構之前的計算程式碼。

import threading
import time
def long_time_task(i):
    print('當前子執行緒: {} - 任務{}'.format(threading.current_thread().name, i))
    time.sleep(2)
    print("結果: {}".format(8 ** 20))
if __name__=='__main__':
    start = time.time()
    print('這是主執行緒：{}'.format(threading.current_thread().name))
    t1 = threading.Thread(target=long_time_task, args=(1,))
    t2 = threading.Thread(target=long_time_task, args=(2,))
    t1.start()
    t2.start()
    end = time.time()
    print("總共用時{}秒".format((end - start)))

下面是輸出結果。為什麼總耗時居然是0秒? 我們可以明顯看到主執行緒和子執行緒其實是獨立執行的，主執行緒根本沒有等子執行緒完成，而是自己結束後就列印了消耗時間。主執行緒結束後，子執行緒仍在獨立執行，這顯然不是我們想要的。

這是主執行緒：MainThread
當前子執行緒: Thread-1 - 任務1
當前子執行緒: Thread-2 - 任務2
總共用時0.0017192363739013672秒
結果: 1152921504606846976
結果: 1152921504606846976

如果要實現主執行緒和子執行緒的同步，我們必需使用join方法（程式碼如下所示)。

import threading
import time
def long_time_task(i):
    print('當前子執行緒: {} 任務{}'.format(threading.current_thread().name, i))
    time.sleep(2)
    print("結果: {}".format(8 ** 20))
if __name__=='__main__':
    start = time.time()
    print('這是主執行緒：{}'.format(threading.current_thread().name))
    thread_list = []
    for i in range(1, 3):
        t = threading.Thread(target=long_time_task, args=(i, ))
        thread_list.append(t)
    for t in thread_list:
        t.start()
    for t in thread_list:
        t.join()
    end = time.time()
    print("總共用時{}秒".format((end - start)))

修改程式碼後的輸出如下所示。這時你可以看到主執行緒在等子執行緒完成後才答應出總消耗時間(2秒)，比正常順序執行程式碼(4秒)還是節省了不少時間。

這是主執行緒：MainThread
當前子執行緒: Thread - 1 任務1
當前子執行緒: Thread - 2 任務2
結果: 1152921504606846976
結果: 1152921504606846976
總共用時2.0166890621185303秒

當我們設定多執行緒時，主執行緒會建立多個子執行緒，在python中，預設情況下主執行緒和子執行緒獨立執行互不干涉。如果希望讓主執行緒等待子執行緒實現執行緒的同步，我們需要使用join()方法。如果我們希望一個主執行緒結束時不再執行子執行緒，我們應該怎麼辦呢? 我們可以使用t.setDaemon(True)，程式碼如下所示。

import threading
import time
def long_time_task():
    print('當子執行緒: {}'.format(threading.current_thread().name))
    time.sleep(2)
    print("結果: {}".format(8 ** 20))
if __name__=='__main__':
    start = time.time()
    print('這是主執行緒：{}'.format(threading.current_thread().name))
    for i in range(5):
        t = threading.Thread(target=long_time_task, args=())
        t.setDaemon(True)
        t.start()
    end = time.time()
    print("總共用時{}秒".format((end - start)))

通過繼承Thread類重寫run方法建立新執行緒

除了使用Thread()方法建立新的執行緒外，我們還可以通過繼承Thread類重寫run方法建立新的執行緒，這種方法更靈活。下例中我們自定義的類為MyThread, 隨後我們通過該類的例項化建立了2個子執行緒。

#-*- encoding:utf-8 -*-
import threading
import time
def long_time_task(i):
    time.sleep(2)
    return 8**20
class MyThread(threading.Thread):
    def __init__(self, func, args , name='', ):
        threading.Thread.__init__(self)
        self.func = func
        self.args = args
        self.name = name
        self.result = None
    def run(self):
        print('開始子程序{}'.format(self.name))
        self.result = self.func(self.args[0],)
        print("結果: {}".format(self.result))
        print('結束子程序{}'.format(self.name))
if __name__=='__main__':
    start = time.time()
    threads = []
    for i in range(1, 3):
        t = MyThread(long_time_task, (i,), str(i))
        threads.append(t)
    for t in threads:
        t.start()
    for t in threads:
        t.join()
    end = time.time()
    print("總共用時{}秒".format((end - start)))

輸出結果如下所示:

開始子程序1
開始子程序2
結果: 1152921504606846976
結果: 1152921504606846976
結束子程序1
結束子程序2
總共用時2.005445718765259秒

不同執行緒間的資料共享

一個程序所含的不同執行緒間共享記憶體，這就意味著任何一個變數都可以被任何一個執行緒修改，因此執行緒之間共享資料最大的危險在於多個執行緒同時改一個變數，把內容給改亂了。如果不同執行緒間有共享的變數，其中一個方法就是在修改前給其上一把鎖lock，確保一次只有一個執行緒能修改它。threading.lock()方法可以輕易實現對一個共享變數的鎖定，修改完後release供其它執行緒使用。比如下例中賬戶餘額balance是一個共享變數，使用lock可以使其不被改亂。

# -*- coding: utf-8 -*
import threading
class Account:
    def __init__(self):
        self.balance = 0
    def add(self, lock):
        # 獲得鎖
        lock.acquire()
        for i in range(0, 100000):
            self.balance += 1
        # 釋放鎖
        lock.release()
    def delete(self, lock):
        # 獲得鎖
        lock.acquire()
        for i in range(0, 100000):
            self.balance -= 1
            # 釋放鎖
        lock.release()
if __name__ == "__main__":
    account = Account()
    lock = threading.Lock()
    # 建立執行緒
   thread_add = threading.Thread(target=account.add, args=(lock,), name='Add')
    thread_delete = threading.Thread(target=account.delete, args=(lock,), name='Delete')
    # 啟動執行緒
   thread_add.start()
    thread_delete.start()
    # 等待執行緒結束
   thread_add.join()
    thread_delete.join()
    print('The final balance is: {}'.format(account.balance))

另一種實現不同執行緒間資料共享的方法就是使用訊息佇列queue。不像列表，queue是執行緒安全的，可以放心使用，見下文。

使用queue佇列通訊-經典的生產者和消費者模型

下例中建立了兩個執行緒，一個負責生成，一個負責消費，所生成的產品存放在queue裡，實現了不同執行緒間溝通。

from queue import Queue
import random, threading, time
# 生產者類
class Producer(threading.Thread):
    def __init__(self, name, queue):
        threading.Thread.__init__(self, name=name)
        self.queue = queue
    def run(self):
        for i in range(1, 5):
            print("{} is producing {} to the queue!".format(self.getName(), i))
            self.queue.put(i)
            time.sleep(random.randrange(10) / 5)
        print("%s finished!" % self.getName())
# 消費者類
class Consumer(threading.Thread):
    def __init__(self, name, queue):
        threading.Thread.__init__(self, name=name)
        self.queue = queue

    def run(self):
        for i in range(1, 5):
            val = self.queue.get()
            print("{} is consuming {} in the queue.".format(self.getName(), val))
            time.sleep(random.randrange(10))
        print("%s finished!" % self.getName())
def main():
    queue = Queue()
    producer = Producer('Producer', queue)
    consumer = Consumer('Consumer', queue)
    producer.start()
    consumer.start()
    producer.join()
    consumer.join()
    print('All threads finished!')
if __name__ == '__main__':
    main()

佇列queue的put方法可以將一個物件obj放入佇列中。如果佇列已滿，此方法將阻塞至佇列有空間可用為止。queue的get方法一次返回佇列中的一個成員。如果佇列為空，此方法將阻塞至佇列中有成員可用為止。queue同時還自帶emtpy(), full()等方法來判斷一個佇列是否為空或已滿，但是這些方法並不可靠，因為多執行緒和多程序，在返回結果和使用結果之間，佇列中可能新增/刪除了成員。

Python多程序和多執行緒哪個快?

由於GIL的存在，很多人認為Python多程序程式設計更快，針對多核CPU，理論上來說也是採用多程序更能有效利用資源。網上很多人已做過比較，我直接告訴你結論吧。

對CPU密集型程式碼(比如迴圈計算) - 多程序效率更高
對IO密集型程式碼(比如檔案操作，網路爬蟲) - 多執行緒效率更高。

為什麼是這樣呢？其實也不難理解。對於IO密集型操作，大部分消耗時間其實是等待時間，在等待時間中CPU是不需要工作的，那你在此期間提供雙CPU資源也是利用不上的，相反對於CPU密集型程式碼，2個CPU幹活肯定比一個CPU快很多。那麼為什麼多執行緒會對IO密集型程式碼有用呢？這因是為python碰到等待會釋放GIL供新的執行緒使用，實現了執行緒間的切換。

GIL是什麼

首先需要明確的一點是GIL並不是Python的特性，它是在實現Python解析器(CPython)時所引入的一個概念。就好比C++是一套語言（語法）標準，但是可以用不同的編譯器來編譯成可執行程式碼。有名的編譯器例如GCC，INTEL C++，Visual C++等。Python也一樣，同樣一段程式碼可以通過CPython，PyPy，Psyco等不同的Python執行環境來執行。像其中的JPython就沒有GIL。然而因為CPython是大部分環境下預設的Python執行環境。所以在很多人的概念裡CPython就是Python，也就想當然的把GIL歸結為Python語言的缺陷。所以這裡要先明確一點：GIL並不是Python的特性，Python完全可以不依賴於GIL。

GIL: 一個防止多執行緒併發執行機器碼的一個Mutex，乍一看就是個BUG般存在的全域性鎖嘛！別急，我們下面慢慢的分析。

為什麼會有GIL

由於物理上得限制，各CPU廠商在核心頻率上的比賽已經被多核所取代。為了更有效的利用多核處理器的效能，就出現了多執行緒的程式設計方式，而隨之帶來的就是執行緒間資料一致性和狀態同步的困難。即使在CPU內部的Cache也不例外，為了有效解決多份快取之間的資料同步時各廠商花費了不少心思，也不可避免的帶來了一定的效能損失。

Python當然也逃不開，為了利用多核，Python開始支援多執行緒。而解決多執行緒之間資料完整性和狀態同步的最簡單方法自然就是加鎖。於是有了GIL這把超級大鎖，而當越來越多的程式碼庫開發者接受了這種設定後，他們開始大量依賴這種特性（即預設python內部物件是thread-safe的，無需在實現時考慮額外的記憶體鎖和同步操作）。

慢慢的這種實現方式被發現是蛋疼且低效的。但當大家試圖去拆分和去除GIL的時候，發現大量庫程式碼開發者已經重度依賴GIL而非常難以去除了。有多難？做個類比，像MySQL這樣的“小專案”為了把Buffer Pool Mutex這把大鎖拆分成各個小鎖也花了從5.5到5.6再到5.7多個大版為期近5年的時間，本且仍在繼續。MySQL這個背後有公司支援且有固定開發團隊的產品走的如此艱難，那又更何況Python這樣核心開發和程式碼貢獻者高度社群化的團隊呢？

所以簡單的說GIL的存在更多的是歷史原因。如果推到重來，多執行緒的問題依然還是要面對，但是至少會比目前GIL這種方式會更優雅。

GIL的影響

從上文的介紹和官方的定義來看，GIL無疑就是一把全域性排他鎖。毫無疑問全域性鎖的存在會對多執行緒的效率有不小影響。甚至就幾乎等於Python是個單執行緒的程式。
那麼讀者就會說了，全域性鎖只要釋放的勤快效率也不會差啊。只要在進行耗時的IO操作的時候，能釋放GIL，這樣也還是可以提升執行效率的嘛。或者說再差也不會比單執行緒的效率差吧。理論上是這樣，而實際上呢？Python比你想的更糟。

下面我們就對比下Python在多執行緒和單執行緒下得效率對比。測試方法很簡單，一個迴圈1億次的計數器函式。一個通過單執行緒執行兩次，一個多執行緒執行。最後比較執行總時間。測試環境為雙核的Mac pro。注：為了減少執行緒庫本身效能損耗對測試結果帶來的影響，這裡單執行緒的程式碼同樣使用了執行緒。只是順序的執行兩次，模擬單執行緒。

順序執行的單執行緒(single_thread.py)

#! /usr/bin/python
 
from threading import Thread
import time
 
def my_counter():
    i = 0
    for _ in range(100000000):
        i = i + 1
    return True
 
def main():
    thread_array = {}
    start_time = time.time()
    for tid in range(2):
        t = Thread(target=my_counter)
        t.start()
        t.join()
    end_time = time.time()
    print("Total time: {}".format(end_time - start_time))
 
if __name__ == '__main__':
    main()

同時執行的兩個併發執行緒(multi_thread.py)

#! /usr/bin/python
 
from threading import Thread
import time
 
def my_counter():
    i = 0
    for _ in range(100000000):
        i = i + 1
    return True
 
def main():
    thread_array = {}
    start_time = time.time()
    for tid in range(2):
        t = Thread(target=my_counter)
        t.start()
        thread_array[tid] = t
    for i in range(2):
        thread_array[i].join()
    end_time = time.time()
    print("Total time: {}".format(end_time - start_time))
 
if __name__ == '__main__':
    main()

python在多執行緒的情況下居然比單執行緒整整慢了45%。按照之前的分析，即使是有GIL全域性鎖的存在，序列化的多執行緒也應該和單執行緒有一樣的效率才對。那麼怎麼會有這麼糟糕的結果呢？

讓我們通過GIL的實現原理來分析這其中的原因。

當前GIL設計的缺陷

基於pcode數量的排程方式

按照Python社群的想法，作業系統本身的執行緒排程已經非常成熟穩定了，沒有必要自己搞一套。所以Python的執行緒就是C語言的一個pthread，並通過作業系統排程演算法進行排程（例如linux是CFS）。為了讓各個執行緒能夠平均利用CPU時間，python會計算當前已執行的微程式碼數量，達到一定閾值後就強制釋放GIL。而這時也會觸發一次作業系統的執行緒排程（當然是否真正進行上下文切換由作業系統自主決定）。

虛擬碼

while True:
    acquire GIL
    for i in 1000:
        do something
    release GIL
    /* Give Operating System a chance to do thread scheduling */

這種模式在只有一個CPU核心的情況下毫無問題。任何一個執行緒被喚起時都能成功獲得到GIL（因為只有釋放了GIL才會引發執行緒排程）。但當CPU有多個核心的時候，問題就來了。從虛擬碼可以看到，從release GIL到acquire GIL之間幾乎是沒有間隙的。所以當其他在其他核心上的執行緒被喚醒時，大部分情況下主執行緒已經又再一次獲取到GIL了。這個時候被喚醒執行的執行緒只能白白的浪費CPU時間，看著另一個執行緒拿著GIL歡快的執行著。然後達到切換時間後進入待排程狀態，再被喚醒，再等待，以此往復惡性迴圈。

PS：當然這種實現方式是原始而醜陋的，Python的每個版本中也在逐漸改進GIL和執行緒排程之間的互動關係。例如先嚐試持有GIL在做執行緒上下文切換，在IO等待時釋放GIL等嘗試。但是無法改變的是GIL的存在使得作業系統執行緒排程的這個本來就昂貴的操作變得更奢侈了。
關於GIL影響的擴充套件閱讀

為了直觀的理解GIL對於多執行緒帶來的效能影響，這裡直接借用的一張測試結果圖（見下圖）。圖中表示的是兩個執行緒在雙核CPU上得執行情況。兩個執行緒均為CPU密集型運算執行緒。綠色部分表示該執行緒在執行，且在執行有用的計算，紅色部分為執行緒被排程喚醒，但是無法獲取GIL導致無法進行有效運算等待的時間。

由圖可見，GIL的存在導致多執行緒無法很好的立即多核CPU的併發處理能力。

那麼Python的IO密集型執行緒能否從多執行緒中受益呢？我們來看下面這張測試結果。顏色代表的含義和上圖一致。白色部分表示IO執行緒處於等待。可見，當IO執行緒收到資料包引起終端切換後，仍然由於一個CPU密集型執行緒的存在，導致無法獲取GIL鎖，從而進行無盡的迴圈等待。

簡單的總結下就是：Python的多執行緒在多核CPU上，只對於IO密集型計算產生正面效果；而當有至少有一個CPU密集型執行緒存在，那麼多執行緒效率會由於GIL而大幅下降。

如何避免受到GIL的影響

說了那麼多，如果不說解決方案就僅僅是個科普帖，然並卵。GIL這麼爛，有沒有辦法繞過呢？我們來看看有哪些現成的方案。

用multiprocess替代Thread

multiprocess庫的出現很大程度上是為了彌補thread庫因為GIL而低效的缺陷。它完整的複製了一套thread所提供的介面方便遷移。唯一的不同就是它使用了多程序而不是多執行緒。每個程序有自己的獨立的GIL，因此也不會出現程序之間的GIL爭搶。

當然multiprocess也不是萬能良藥。它的引入會增加程式實現時執行緒間資料通訊和同步的困難。就拿計數器來舉例子，如果我們要多個執行緒累加同一個變數，對於thread來說，申明一個global變數，用thread.Lock的context包裹住三行就搞定了。而multiprocess由於程序之間無法看到對方的資料，只能通過在主執行緒申明一個Queue，put再get或者用share memory的方法。這個額外的實現成本使得本來就非常痛苦的多執行緒程式編碼，變得更加痛苦了。

用其他解析器

之前也提到了既然GIL只是CPython的產物，那麼其他解析器是不是更好呢？沒錯，像JPython和IronPython這樣的解析器由於實現語言的特性，他們不需要GIL的幫助。然而由於用了Java/C#用於解析器實現，他們也失去了利用社群眾多C語言模組有用特性的機會。所以這些解析器也因此一直都比較小眾。畢竟功能和效能大家在初期都會選擇前者，Done is better than perfect。

所以沒救了麼？

當然Python社群也在非常努力的不斷改進GIL，甚至是嘗試去除GIL。並在各個小版本中有了不少的進步。

另一個改進Reworking the GIL
– 將切換顆粒度從基於opcode計數改成基於時間片計數
– 新增執行緒優先順序功能（高優先順序執行緒可以迫使其他執行緒釋放所持有的GIL鎖）
– 避免最近一次釋放GIL鎖的執行緒再次被立即排程

總結

Python GIL其實是功能和效能之間權衡後的產物，它尤其存在的合理性，也有較難改變的客觀因素。從本問的分析中，我們可以做以下一些簡單的總結：

因為GIL的存在，只有IO Bound場景下得多執行緒會得到較好的效能
如果對平行計算效能較高的程式可以考慮把核心部分也成C模組，或者索性用其他語言實現
GIL在較長一段時間內將會繼續存在，但是會不斷對其進行改進

參考資料：

Python多程序與多執行緒程式設計及GIL詳解

一文看懂Python多程序與多執行緒程式設計

python中的GIL詳解

Python多程序與多執行緒程式設計及GIL詳解

瀏覽器多程序與JS執行緒

Android 多執行緒程式設計之 HandlerThread 詳解

Python 守護程序與守護執行緒

java執行緒（上）——執行緒狀態及屬性詳解

Kafka單執行緒Consumer及引數詳解

一文看懂Python多程序與多執行緒程式設計(工作學習面試必讀)

python多程序與多執行緒！

網路程式設計中設計併發伺服器，使用多程序與多執行緒有什麼區別？

python筆記--多程序與多執行緒

【Linux】多程序與多執行緒之間的區別

多程序與多執行緒

多程序與多執行緒（三）--多程序 or 多執行緒(轉)

多程序與多執行緒（五）--Linux 執行緒模型的比較：LinuxThreads 和 NPTL(轉)

多程序與多執行緒（一）--基本概念(轉)

多程序與多執行緒（七）--多執行緒效率(轉)

多程序與多執行緒（二）--魚與熊掌(轉)

多程序與多執行緒（六）--LinuxThreads(轉)

多程序與多執行緒（四）--NPTL(轉)

多程序與多執行緒（八）--Linux 執行緒實現機制分析 (轉)

Python多程序與多執行緒程式設計及GIL詳解

一文看懂Python多程序與多執行緒程式設計

python中的GIL詳解

相關推薦