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

那麼CPython實現中的GIL又是什麼呢？GIL全稱Global Interpreter Lock爲了避免誤導，我們還是來看一下官方給出的解釋：

In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.)

好吧，是不是看上去很糟糕？

即全局解釋器鎖，每個線程在執行時候都需要先獲取GIL，保證同一時刻只有一個線程可以執行代碼，即同一時刻只有一個線程使用CPU，也就是說多線程並不是真正意義上的同時執行。

爲什麼會有GIL

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

Python當然也逃不開，爲了利用多核，Python開始支持多線程。而解決多線程之間數據完整性和狀態同步的最簡單方法自然就是加鎖。 於是有了GIL這把超級大鎖，而當越來越多的代碼庫開發者接受了這種設定後，他們開始大量依賴這種特性（即默認python內部對象是thread-safe的，無需在實現時考慮額外的內存鎖和同步操作）。

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

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

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

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

如何改進GIL帶來的影響

• 更換cpython爲jpython(不建議)
• 使用多進程完成多線程的任務
• 在使用多線程可以使用c語言去實現

用multiprocessing替代Thread

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

當然multiprocessing也不是萬能良藥。它的引入會增加程序實現時線程間數據通訊和同步的困難。就拿計數器來舉例子，如果我們要多個線程累加同一個變量，對於thread來說，申明一個global變量，用thread.Lock的context包裹住三行就搞定了。而multiprocessing由於進程之間無法看到對方的數據，只能通過在主線程申明一個Queue，put再get或者用share memory的方法。這個額外的實現成本使得本來就非常痛苦的多線程程序編碼，變得更加痛苦了。具體難點在哪有興趣的讀者可以擴展閱讀這篇文章

多進程通信

Queue

多個進程間實現通信

Queue有兩個方法

1. Put

   以插入數據到隊列中，他還有兩個可選參數：blocked和timeout。

2. Get

   從隊列讀取並且刪除一個元素。同樣，他還有兩個可選參數：blocked和timeout。

#!coding:utf-8
from multiprocessing import Process, Queue
import os,time,random

#寫數據進程執行的代碼
def proc_write(q,urls):
    print 'Process is write....'
    for url in urls:
        q.put(url)
        print 'put %s to queue... ' %url
        time.sleep(random.random())

#讀數據進程的代碼
def proc_read(q):
    print('Process is reading...')
    while True:
        url = q.get(True)
        print('Get %s from queue' %url)

if __name__ == '__main__':
    #父進程創建Queue，並傳給各個子進程
    q = Queue()
    proc_write1 = Process(target=proc_write,args=(q,['url_1','url_2','url_3']))
    proc_write2 = Process(target=proc_write,args=(q,['url_4','url_5','url_6']))
    proc_reader = Process(target=proc_read,args=(q,))
    #啓動子進程，寫入
    proc_write1.start()
    proc_write2.start()

    proc_reader.start()
    #等待proc_write1結束
    proc_write1.join()
    proc_write2.join()
    #proc_raader進程是死循環，強制結束
    proc_reader.terminate()

運行結果圖：

Pipe

兩個進程間的通信

• Pipe常用於兩個進程，兩個進程分別位於管道的兩端
• Pipe方法返回（conn1,conn2）代表一個管道的兩個端，Pipe方法有duplex參數，默認爲True，即全雙工模式，若爲FALSE，conn1只負責接收信息，conn2負責發送，
• send和recv方法分別爲發送和接收信息。

#!coding:utf-8
import multiprocessing
import os,time,random

#寫數據進程執行的代碼
def proc_send(pipe,urls):
    #print 'Process is write....'
    for url in urls:

        print 'Process is send :%s' %url
        pipe.send(url)
        time.sleep(random.random())

#讀數據進程的代碼
def proc_recv(pipe):
    while True:
        print('Process rev:%s' %pipe.recv())
        time.sleep(random.random())

if __name__ == '__main__':
    #父進程創建pipe，並傳給各個子進程
    pipe = multiprocessing.Pipe()
    p1 = multiprocessing.Process(target=proc_send,args=(pipe[0],['url_'+str(i) for i in range(10) ]))
    p2 = multiprocessing.Process(target=proc_recv,args=(pipe[1],))
    #啓動子進程，寫入
    p1.start()
    p2.start()

    p1.join()
    p2.terminate()

運行結果圖：

GIL相關問題

什麼時候會釋放Gil鎖

• 遇到像 i/o操作這種 會有時間空閒情況 造成cpu閒置的情況會釋放Gil
• 會有一個專門ticks進行計數 一旦ticks數值達到100 這個時候釋放Gil鎖 線程之間開始競爭Gil鎖(說明:ticks這個數值可以進行設置來延長或者縮減獲得Gil鎖的線程使用cpu的時間)

互斥鎖和Gil鎖的關係

Gil鎖 : 保證同一時刻只有一個線程能使用到cpu
互斥鎖: 多線程時,保證修改共享數據時有序的修改,不會產生數據修改混亂

首先假設只有一個進程,這個進程中有兩個線程 Thread1,Thread2, 要修改共享的數據data, 並且有互斥鎖

執行以下步驟:

1. 多線程運行，假設Thread1獲得GIL可以使用cpu，這時Thread1獲得 互斥鎖lock,Thread1可以改data數據(但並
   沒有開始修改數據)
2. Thread1線程在修改data數據前發生了 i/o操作 或者ticks計數滿100 (注意就是沒有運行到修改data數據),這個
   時候 Thread1讓出了GIL,GIL鎖可以被競爭
3. Thread1 和 Thread2 開始競爭 Gil (注意:如果Thread1是因爲 i/o 阻塞 讓出的Gil Thread2必定拿到Gil,如果
   Thread1是因爲ticks計數滿100讓出Gil 這個時候 Thread1 和 Thread2 公平競爭)
4. 假設 Thread2正好獲得了GIL, 運行代碼去修改共享數據 data,由於Thread1有互斥鎖lock，所以Thread2無法更改共享數據data,這時Thread2讓出GIL鎖 ,GIL鎖再次發生競爭
   公平競爭)
5. 假設 Thread2正好獲得了GIL, 運行代碼去修改共享數據 data,由於Thread1有互斥鎖lock，所以Thread2無法更改共享數據data,這時Thread2讓出GIL鎖 ,GIL鎖再次發生競爭
6. 假設Thread1又搶到GIL，由於其有互斥鎖Lock所以其可以繼續修改共享數據data,當Thread1修改完數據釋放互斥鎖lock,Thread2在獲得GIL與lock後纔可對data進行修改