2. 程式人生 > >Python 多執行緒 多程序 GIL

Python 多執行緒 多程序 GIL

阿新 • • 發佈：2019-01-27

多執行緒

使用threading模組建立執行緒

傳入一個函式

這種方式是最基本的，即呼叫threading中的Thread類的建構函式，然後指定引數target=func，再使用返回的Thread的例項呼叫start()方法，即開始執行該執行緒，該執行緒將執行函式func，當然，如果func需要引數，可以在Thread的建構函式中傳入引數args=(…)。示例程式碼如下

import threading
#用於執行緒執行的函式
def counter(n):
    cnt = 0;
    for i in xrange(n):
        for j in xrange(i):
            cnt += j;
    print
 
 cnt;
if __name__ == '__main__':
    #初始化一個執行緒物件，傳入函式counter，及其引數1000
    th = threading.Thread(target=counter, args=(1000,));
    #啟動執行緒
    th.start();
    #主執行緒阻塞等待子執行緒結束
    th.join();

傳入一個可呼叫的物件

許多的python 物件都是我們所說的可呼叫的，即是任何能通過函式操作符“（）”來呼叫的物件（見《python核心程式設計》第14章）。類的物件也是可以呼叫的，當被呼叫時會自動呼叫物件的內建方法call()，因此這種新建執行緒的方法就是給執行緒指定一個call

方法被過載了的物件。示例程式碼如下：

import threading
#可呼叫的類
class Callable(object):
    def __init__(self, func, args):
        self.func = func;
        self.args = args;
    def __call__(self):
        apply(self.func, self.args);
#用於執行緒執行的函式
def counter(n):
    cnt = 0;
    for i in xrange(n):
        for j in xrange(i):
            cnt += j;
    print
 
 cnt;
if __name__ == '__main__':
    #初始化一個執行緒物件，傳入可呼叫的Callable物件，並用函式counter及其引數1000初始化這個物件
    th = threading.Thread(target=Callable(counter, (1000,)));
    #啟動執行緒
    th.start();
    #主執行緒阻塞等待子執行緒結束
    th.join();

這個例子關鍵的一句是apply(self.func, self.args); 這裡使用初始化時傳入的函式物件及其引數來進行一次呼叫

繼承Thread類

這種方式通過繼承Thread類，並重載其run方法，來實現自定義的執行緒行為，示例程式碼如下：

import threading, time, random
def counter():
    cnt = 0;
    for i in xrange(10000):
        for j in xrange(i):
            cnt += j;
class SubThread(threading.Thread):
    def __init__(self, name):
        threading.Thread.__init__(self, name=name);
    def run(self):
        i = 0;
        while i < 4:
            print self.name,'counting...\n';
            counter();
            print self.name,'finish\n';
            i += 1;
if __name__ == '__main__':
    th = SubThread('thread-1');
    th.start();
    th.join();
    print 'all done';

使用multiprocessing建立程序

傳入一個函式

  • 程序的建立方式跟執行緒完全一致，只不過要將threading.Thread換成multiprocessing.Process。multiprocessing模組盡力保持了與threading模組在方法名上的一致性，示例程式碼可參考上面執行緒部分的。這裡只給出第一種使用函式的方式
import multiprocessing, time
def run():
    i = 0;
    while i<10000:
        print 'running';
        time.sleep(2);
        i += 1;
if __name__ == '__main__':
    p = multiprocessing.Process(target=run);
    p.start();
    #p.join();
    print p.pid;
    print 'master gone';

建立程序池

  • 該模組還允許一次建立一組程序，然後再給他們分配任務。詳細內容可參考手冊，這部分研究不多，不敢亂寫。
pool = multiprocessing.Pool(processes=4)
pool.apply_async(func, args...)

使用程序的好處

  • 完全並行，無GIL的限制，可充分利用多cpu多核的環境；可以接受linux訊號，後面將看到，這個功能非常好用

GIL

  • python多執行緒有個討厭的限制，全域性直譯器鎖（global interpreter lock），這個鎖的意思是任一時間只能有一個執行緒使用直譯器，跟單cpu跑多個程式一個意思，大家都是輪著用的，這叫“併發”，不是“並行”。
  • 手冊上的解釋是為了保證物件模型的正確性！這個鎖造成的困擾是如果有一個計算密集型的執行緒佔著cpu，其他的執行緒都得等著….，試想你的多個執行緒中有這麼一個執行緒，得多悲劇，多執行緒生生被搞成序列；當然這個模組也不是毫無用處，
  • 手冊上又說了：當用於IO密集型任務時，IO期間執行緒會釋放直譯器，這樣別的執行緒就有機會使用直譯器了！所以是否使用這個模組需要考慮面對的任務型別。

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.)
  • 好吧，是不是看上去很糟糕？一個防止多執行緒併發執行機器碼的一個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導致無法進行有效運算等待的時間。
  • 簡單的總結下就是：Python的多執行緒在多核CPU上，只對於IO密集型計算產生正面效果；而當有至少有一個CPU密集型執行緒存在，那麼多執行緒效率會由於GIL而大幅下降

如何避免受到GIL的影響

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

用multiprocessing替代Thread

  • multiprocessing庫的出現很大程度上是為了彌補thread庫因為GIL而低效的缺陷。它完整的複製了一套thread所提供的介面方便遷移。唯一的不同就是它使用了多程序而不是多執行緒。每個程序有自己的獨立的GIL，因此也不會出現程序之間的GIL爭搶。
  • 當然multiprocessing也不是萬能良藥。它的引入會增加程式實現時執行緒間資料通訊和同步的困難。就拿計數器來舉例子，如果我們要多個執行緒累加同一個變數，對於thread來說，申明一個global變數，用thread.Lock的context包裹住三行就搞定了。而multiprocessing由於程序之間無法看到對方的資料，只能通過在主執行緒申明一個Queue，put再get或者用share memory的方法。這個額外的實現成本使得本來就非常痛苦的多執行緒程式編碼，變得更加痛苦了。具體難點在哪有興趣的讀者可以擴充套件閱讀這篇文章

用其他解析器

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

所以沒救了麼？

  • 當然Python社群也在非常努力的不斷改進GIL，甚至是嘗試去除GIL。並在各個小版本中有了不少的進步。有興趣的讀者可以擴充套件閱讀這個Slide 另一個改進Reworking the GIL - 將切換顆粒度從基於opcode計數改成基於時間片計數 - 避免最近一次釋放GIL鎖的執行緒再次被立即排程 - 新增執行緒優先順序功能（高優先順序執行緒可以迫使其他執行緒釋放所持有的GIL鎖）

總結

  • Python GIL其實是功能和效能之間權衡後的產物，它尤其存在的合理性，也有較難改變的客觀因素。從本分的分析中，我們可以做以下一些簡單的總結： - 因為GIL的存在，只有IO Bound場景下得多執行緒會得到較好的效能 - 如果對平行計算效能較高的程式可以考慮把核心部分也成C模組，或者索性用其他語言實現 - GIL在較長一段時間內將會繼續存在，但是會不斷對其進行改進

相關推薦

Python 多執行緒 多程序 全域性直譯器鎖GIL join

Python 程式碼的執行由Python 虛擬機器(也叫直譯器主迴圈)來控制。Python 在設計之初就考慮到要在主迴圈中，同時只有一個執行緒在執行，就像單CPU 的系統中執行多個程序那樣，記憶體中可以存放多個程式，但任意時刻，只有一個程式在CPU 中執行。同樣地，雖然Py

Python 多執行緒 多程序 GIL

多執行緒 使用threading模組建立執行緒 傳入一個函式 這種方式是最基本的，即呼叫threading中的Thread類的建構函式，然後指定引數target=func，再使用返回的Thread的例項呼叫start()方法，即開始執行該執

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

介紹如何使用python的multiprocess和threading模組進行多執行緒和多程序程式設計。 Python的多程序程式設計與multiprocess模組 python的多程序程式設計主要依靠multiprocess模組。我們先對比兩段程式碼，看看多程序程式設計的優勢。我們模擬了一個非常耗時的任

Python 多執行緒 多程序 協程 yield

python中多執行緒和多程序的最大區別是穩定性和效率問題 多程序互相之間不影響,一個崩潰了不影響其他程序,穩定性高 多執行緒因為都在同一程序裡,一個執行緒崩潰了整個程序都完蛋 多程序對系統資源開銷大,多執行緒對系統資源開銷小,所以這方面來說多執行緒會比多程序快一點點 關於執行

python多執行緒——1、GIL

一、GIL是什麼？        執行緒全域性鎖（Global Interpreter lock）,python保護執行緒安全而採取的獨立執行緒執行的限制。      1、明確一點GIL並不是python的特性，pytho

理解一下Python中的多執行緒,多程序,多協程

程序 一個執行的程式（程式碼）就是一個程序，沒有執行的程式碼叫程式，程序是系統資源分配的最小單位，程序擁有自己獨立的記憶體空間，所以程序間資料不共享，開銷大。 執行緒， 排程執行的最小單位，也叫執行路徑，不能獨立存在，依賴程序存在一個程序至少有一個執行緒,叫主執行緒，而多

python之多執行緒多程序併發通訊

1.獨立的程序記憶體空間與共享的伺服器程序空間 程序之間是：互不干擾的獨立記憶體空間 #!/usr/bin/env python # -*- coding: utf-8 -*- # @Time :

python多執行緒 多程序

多程序與多執行緒 我們都知道，作業系統中所有的程式都是以程序的方式來執行的，或者說我們把執行著的程式稱為程序(Process)。例如執行記事本程式就是啟動一個記事本程序，執行兩個記事本就是啟動兩個記事本程序。 很多時候，程序還不止同時幹一件事，比如Word，它可以同時

【Python】單執行緒非同步多執行緒多程序例項

上一篇文章主要介紹了多工場景下單執行緒非同步、多執行緒、多程序如何選擇，連結：多工場景下單執行緒非同步多執行緒多程序 這裡主要通過三個例項去驗證一下簡單的多工場景下，三種方式的耗時情況，假設有10個互不關聯的10個任務 ''''''''' 多程序版本： 使用多程序，時間比多執行緒更慢，為什麼

Python多執行緒/多程序操作佇列

最近在做深度學習，需要採用多程序的方式實現資料處理。為了實現資料的快速處理，我先後嘗試了把資料一口氣讀入記憶體、多執行緒和多程序的方式。當然，肯定是多程序雙佇列的方式最好，因為可以充分利用多核和cpu。 一般來說匯入佇列可以這樣操作： import Queue myqueu

python 多執行緒 多程序使用案例

python開發多程序有兩種方案，首先是os模組下封裝了fork，叉子函式，其實就是廣為人知道的linux下的叉子函式，用法是一樣的，但是現在我介紹一種跨平臺的開程序的方法：該方式可以用於mac，windows，linux，特別屌 首先匯入模組： import os fr

Python 多執行緒多程序

前提 我是參考 Github Python 100 天的文章寫的，再結合自己的小練習，總結 最近在面大廠，發現許多大廠都會問 Python 的多執行緒、多程序，所以我覺得很有必要總結學習下   什麼是程序 作業系統中執行的一個程式，類似微信、QQ，每個程式都是一個程序 概念 它是 CPU

多執行緒多程序使用場景

Python36 多執行緒、多程序的使用場景 多執行緒與多程序的使用場景 io 操作不佔用CPU（從硬碟、從網路、從記憶體讀資料都算io） 計算佔用CPU（如1+1計算） python中的執行緒是假執行緒，不同執行緒之間的切換是需要耗費資源的，因為需要儲存執行緒的上下文，不斷的切換就

python 念聽網mp3多執行緒多工下載

#coding=utf-8 import requests import threading import re class downloader: # 建構函式 def __init__(self,downloadurl): # 設定url

python 多執行緒多工內網攝像頭登陸

python 多執行緒多工內網攝像頭登陸 #coding=utf-8 import time import datetime import xlwt import xlrd from xlutils.copy import copy; import requests import so

python 多執行緒多佇列

我們常常目標具有多工，所以我們才多佇列，但是為了提高速度，常常採用多執行緒，所以多執行緒多佇列 #coding=utf-8 import Queue import threading import urllib2 import time from BeautifulSoup import

java建立多執行緒&建立程序

概述 併發和並行是即相似又有區別： 並行：指兩個或多個事件在同一時刻發生； 併發：指兩個或多個事件在同一時間段內發生。 程序是指一個記憶體中執行中的應用程式。每個程序都有自己獨立的一塊記憶體空間，一個應用程式可以同時啟動多個程序。比如在Windows系統中，一個執行的abc.exe就是一個程序。 那麼我們

linux gdb 除錯多執行緒 多程序 顯示巨集

                一、gdb除錯多執行緒gdb）info thread 檢視當前程序的執行緒。 gdb）thread <ID> 切換除錯的執行緒為指定ID的執行緒。 gdb）break file.c:100 thread all  在file.c檔案第100行處為所有經過這裡的執行緒

Python3基礎之（三十 一）多執行緒&多程序

一、多執行緒 Threading 多執行緒 Threading 是一種讓程式擁有分身效果. 能同時處理多件事情. 一般的程式只能從上到下一行行執行程式碼, 不過多執行緒 (Threading)就能打破這

多工場景下單執行緒非同步多執行緒多程序

多工的場景：1.爬取不同url的內容，爬取同一個url分頁內容。比如：豆瓣圖書 Top 250 https://book.douban.com/top250?start=0 實現豆瓣圖書Top250的抓取工作，並存入excel中，如果採用的序列爬取方式，每次爬完250頁都需要花費7到8分鐘，顯然讓人