6歲時，我有一個音樂盒。我上緊發條，音樂盒頂上的芭蕾舞女演員就會旋轉起來，同時，內部裝置發出“一閃一閃亮晶晶，滿天都是小星星”的叮鈴聲。那玩意兒肯定俗氣透了，但我喜歡那個音樂盒，我想知道它的工作原理是什麼。後來我拆開了，才看到它裡面一個簡單的裝置，機身內部鑲嵌著一個拇指大小的金屬圓筒，當它轉動時會撥弄鋼製的梳齒，從而發出這些音符。

在一個程式設計師具備的所有特性中，想探究事物運轉規律的這種好奇心必不可少。當我開啟音樂盒，觀察內部裝置，可以看出即使我沒有成長為一個卓越的程式設計師，至少也是有好奇心的一個。

奇怪的是，我寫 Python 程式多年，一直對全域性直譯器鎖（GIL）持有錯誤的觀念，因為我從未對它的運作機理產生足夠好奇。我遇到其他對此同樣猶豫和無知的人。是時候讓我們來開啟這個盒子一窺究竟了。讓我們解讀 CPython 直譯器原始碼，找出 GIL 究竟是什麼，為什麼它存在於 Python 中，它又是怎麼影響多執行緒程式的。我將通過舉例幫助你深入理解 GIL 。你將會學到如何寫出快速執行和執行緒安全的 Python 程式碼，以及如何線上程和程序中做選擇。

（我在本文中只描述 CPython，而不是 Jython、PyPy 或  IronPython。因為目前絕大多數程式設計師還是使用 CPython 實現 Python 。）

瞧，全域性直譯器鎖（GIL）

這裡：

static PyThread_type_lock interpreter_lock = 0; /* This is the GIL */

1	staticPyThread_type_lock interpreter_lock=0;/* This is the GIL */

這一行程式碼摘自 ceval.c —— CPython 2.7 直譯器的原始碼，Guido van Rossum 的註釋”This is the GIL“ 添加於2003 年，但這個鎖本身可以追溯到1997年他的第一個多執行緒 Python 直譯器。在 Unix系統中，PyThread_type_lock 是標準 C  mutex_t 鎖的別名。當 Python 直譯器啟動時它初始化：

void PyEval_InitThreads(void) { interpreter_lock = PyThread_allocate_lock(); PyThread_acquire_lock(interpreter_lock); }

123456

voidPyEval_InitThreads(void){interpreter_lock=PyThread_allocate_lock();PyThread_acquire_lock(interpreter_lock);}

直譯器中的所有 C 程式碼在執行 Python 時必須保持這個鎖。Guido 最初加這個鎖是因為它使用起來簡單。而且每次從 CPython 中去除 GIL 的嘗試會耗費單執行緒程式太多效能，儘管去除 GIL 會帶來多執行緒程式效能的提升，但仍是不值得的。（前者是Guido最為關切的, 也是不去除 GIL 最重要的原因, 一個簡單的嘗試是在1999年, 最終的結果是導致單執行緒的程式速度下降了幾乎2倍.）

GIL 對程式中執行緒的影響足夠簡單，你可以在手背上寫下這個原則：“一個執行緒執行 Python ，而其他 N 個睡眠或者等待 I/O.”（即保證同一時刻只有一個執行緒對共享資源進行存取）  Python 執行緒也可以等待threading.Lock或者執行緒模組中的其他同步物件；執行緒處於這種狀態也稱之為”睡眠“。

執行緒何時切換？一個執行緒無論何時開始睡眠或等待網路 I/O，其他執行緒總有機會獲取 GIL 執行 Python 程式碼。這是協同式多工處理。CPython 也還有搶佔式多工處理。如果一個執行緒不間斷地在 Python 2 中執行 1000 位元組碼指令，或者不間斷地在 Python 3 執行15 毫秒，那麼它便會放棄 GIL，而其他執行緒可以執行。把這想象成舊日有多個執行緒但只有一個 CPU 時的時間片。我將具體討論這兩種多工處理。

把 Python 看作是舊時的大型主機，多個任務共用一個CPU。

協同式多工處理

當一項任務比如網路 I/O啟動，而在長的或不確定的時間，沒有執行任何 Python 程式碼的需要，一個執行緒便會讓出GIL，從而其他執行緒可以獲取 GIL 而執行 Python。這種禮貌行為稱為協同式多工處理，它允許併發；多個執行緒同時等待不同事件。

也就是說兩個執行緒各自分別連線一個套接字： def do_connect(): s = socket.socket() s.connect(('python.org', 80)) # drop the GIL   for i in range(2): t = threading.Thread(target=do_connect) t.start()

1234567

def do_connect():s=socket.socket()s.connect(('python.org',80))# drop the GILforiinrange(2):t=threading.Thread(target=do_connect)t.start()

兩個執行緒在同一時刻只能有一個執行 Python ，但一旦執行緒開始連線，它就會放棄 GIL ，這樣其他執行緒就可以執行。這意味著兩個執行緒可以併發等待套接字連線，這是一件好事。在同樣的時間內它們可以做更多的工作。

讓我們開啟盒子，看看一個執行緒在連線建立時實際是如何放棄 GIL 的，在 socketmodule.c 中:

/* s.connect((host, port)) method */ static PyObject * sock_connect(PySocketSockObject *s, PyObject *addro) { sock_addr_t addrbuf; int addrlen; int res;   /* convert (host, port) tuple to C address */ getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen);   Py_BEGIN_ALLOW_THREADS res = connect(s->sock_fd, addr, addrlen); Py_END_ALLOW_THREADS   /* error handling and so on .... */ }

1234567891011121314151617

/* s.connect((host, port)) method */staticPyObject *sock_connect(PySocketSockObject *s,PyObject *addro){sock_addr_t addrbuf;intaddrlen;intres;/* convert (host, port) tuple to C address */getsockaddrarg(s,addro,SAS2SA(&addrbuf),&addrlen);Py_BEGIN_ALLOW_THREADSres=connect(s->sock_fd,addr,addrlen);Py_END_ALLOW_THREADS/* error handling and so on .... */}

執行緒正是在Py_BEGIN_ALLOW_THREADS 巨集處放棄 GIL；它被簡單定義為：

PyThread_release_lock(interpreter_lock);

1	PyThread_release_lock(interpreter_lock);

當然 Py_END_ALLOW_THREADS 重新獲取鎖。一個執行緒可能會在這個位置堵塞，等待另一個執行緒釋放鎖；一旦這種情況發生，等待的執行緒會搶奪回鎖，並恢復執行你的Python程式碼。簡而言之：當N個執行緒在網路 I/O 堵塞，或等待重新獲取GIL，而一個執行緒執行Python。

下面來看一個使用協同式多工處理快速抓取許多 URL 的完整例子。但在此之前，先對比下協同式多工處理和其他形式的多工處理。

搶佔式多工處理

Python執行緒可以主動釋放 GIL，也可以先發制人抓取 GIL 。

讓我們回顧下 Python 是如何執行的。你的程式分兩個階段執行。首先，Python文字被編譯成一個名為位元組碼的簡單二進位制格式。第二，Python直譯器的主迴路，一個名叫 pyeval_evalframeex() 的函式，流暢地讀取位元組碼，逐個執行其中的指令。

當直譯器通過位元組碼時，它會定期放棄GIL，而不需要經過正在執行程式碼的執行緒允許，這樣其他執行緒便能執行：

for (;;) { if (--ticker < 0) { ticker = check_interval;   /* Give another thread a chance */ PyThread_release_lock(interpreter_lock);   /* Other threads may run now */   PyThread_acquire_lock(interpreter_lock, 1); }   bytecode = *next_instr++; switch (bytecode) { /* execute the next instruction ... */ } }

1234567891011121314151617

for(;;){if(--ticker<0){ticker=check_interval;/* Give another thread a chance */PyThread_release_lock(interpreter_lock);/* Other threads may run now */PyThread_acquire_lock(interpreter_lock,1);}bytecode=*next_instr++;switch(bytecode){/* execute the next instruction ... */}}

預設情況下，檢測間隔是1000 位元組碼。所有執行緒都執行相同的程式碼，並以相同的方式定期從他們的鎖中抽出。在 Python 3 GIL 的實施更加複雜，檢測間隔不是一個固定數目的位元組碼，而是15 毫秒。然而，對於你的程式碼，這些差異並不顯著。

Python中的執行緒安全

將多個線狀物編織在一起，需要技能。

如果一個執行緒可以隨時失去 GIL，你必須使讓程式碼執行緒安全。 然而 Python 程式設計師對執行緒安全的看法大不同於 C 或者 Java 程式設計師，因為許多 Python 操作是原子的。

在列表中呼叫 sort()，就是原子操作的例子。執行緒不能在排序期間被打斷，其他執行緒從來看不到列表排序的部分，也不會在列表排序之前看到過期的資料。原子操作簡化了我們的生活，但也有意外。例如，+ = 似乎比 sort() 函式簡單，但+ =不是原子操作。你怎麼知道哪些操作是原子的，哪些不是？ 看看這個程式碼： n = 0 def foo(): global n n += 1

12345

n=0def foo():globalnn+=1

我們可以看到這個函式用 Python 的標準 dis 模組編譯的位元組碼：

>>> import dis >>> dis.dis(foo) LOAD_GLOBAL 0 (n) LOAD_CONST 1 (1) INPLACE_ADD STORE_GLOBAL 0 (n)

123456

>>>import dis>>>dis.dis(foo)LOAD_GLOBAL0(n)LOAD_CONST1(1)INPLACE_ADDSTORE_GLOBAL0(n)

程式碼的一行中， n += 1，被編譯成 4 個位元組碼，進行 4 個基本操作：

1. 將 n 值載入到堆疊上
2. 將常數 1 載入到堆疊上
3. 將堆疊頂部的兩個值相加
4. 將總和儲存回 n

記住，一個執行緒每執行 1000 位元組碼，就會被直譯器打斷奪走 GIL 。如果運氣不好，這（打斷）可能發生線上程載入 n 值到堆疊期間，以及把它儲存回 n 期間。很容易可以看到這個過程會如何導致更新丟失： threads = [] for i in range(100): t = threading.Thread(target=foo) threads.append(t) for t in threads: t.start() for t in threads: t.join() print(n)

123456789101112

threads=[]foriinrange(100):t=threading.Thread(target=foo)threads.append(t)fortinthreads:t.start()fortinthreads:t.join()print(n)

通常這個程式碼輸出 100，因為 100 個執行緒每個都遞增 n 。但有時你會看到 99 或 98 ，如果一個執行緒的更新被另一個覆蓋。 所以，儘管有 GIL，你仍然需要加鎖來保護共享的可變狀態： n = 0 lock = threading.Lock() def foo(): global n with lock: n += 1

1234567

n=0lock=threading.Lock()def foo():globalnwith lock:n+=1

如果我們使用一個原子操作比如 sort() 函式會如何呢？：

lst = [4, 1, 3, 2] def foo(): lst.sort()

1234	lst=[4,1,3,2]def foo():lst.sort()

這個函式的位元組碼顯示 sort() 函式不能被中斷，因為它是原子的：

>>> dis.dis(foo) LOAD_GLOBAL 0 (lst) LOAD_ATTR 1 (sort) CALL_FUNCTION 0

1234	>>>dis.dis(foo)LOAD_GLOBAL0(lst)LOAD_ATTR1(sort)CALL_FUNCTION0

一行被編譯成 3 個位元組碼：

1. 將 lst 值載入到堆疊上
2. 將其排序方法載入到堆疊上
3. 呼叫排序方法

即使這一行  lst.sort() 分幾個步驟，呼叫 sort 自身是單個位元組碼，因此執行緒沒有機會在呼叫期間抓取 GIL 。我們可以總結為在 sort() 不需要加鎖。或者，為了避免擔心哪個操作是原子的，遵循一個簡單的原則：始終圍繞共享可變狀態的讀取和寫入加鎖。畢竟，在 Python 中獲取一個 threading.Lock 是廉價的。

儘管 GIL 不能免除我們加鎖的需要，但它確實意味著沒有加細粒度的鎖的需要（所謂細粒度是指程式設計師需要自行加、解鎖來保證執行緒安全，典型代表是 Java , 而 CPthon 中是粗粒度的鎖，即語言層面本身維護著一個全域性的鎖機制,用來保證執行緒安全）。線上程自由的語言比如 Java，程式設計師努力在儘可能短的時間內加鎖存取共享資料，減輕執行緒爭奪，實現最大並行。然而因為在 Python 中執行緒無法並行執行，細粒度鎖沒有任何優勢。只要沒有執行緒保持這個鎖，比如在睡眠，等待I/O, 或者一些其他失去 GIL 操作，你應該使用盡可能粗粒度的，簡單的鎖。其他執行緒無論如何無法並行執行。

併發可以完成更快

我敢打賭你真正為的是通過多執行緒來優化你的程式。通過同時等待許多網路操作，你的任務將更快完成，那麼多執行緒會起到幫助，即使在同一時間只有一個執行緒可以執行 Python 。這就是併發，執行緒在這種情況下工作良好。

執行緒中程式碼執行更快

import threading import requests urls = [...] def worker(): while True: try: url = urls.pop() except IndexError: break # Done. requests.get(url) for _ in range(10): t = threading.Thread(target=worker) t.start()

1234567891011121314151617

import threadingimport requestsurls=[...]def worker():whileTrue:try:url=urls.pop()except IndexError:break# Done.requests.get(url)for_inrange(10):t=threading.Thread(target=worker)t.start()

正如我們所看到的，在 HTTP上面獲取一個URL中，這些執行緒在等待每個套接字操作時放棄 GIL，所以他們比一個執行緒更快完成工作。

Parallelism 並行

如果想只通過同時執行 Python 程式碼，而使任務完成更快怎麼辦？這種方式稱為並行，這種情況 GIL 是禁止的。你必須使用多個程序，這種情況比執行緒更復雜，需要更多的記憶體，但它可以更好利用多個 CPU。

這個例子 fork 出 10 個程序，比只有 1 個程序要完成更快，因為程序在多核中並行執行。但是 10 個執行緒與 1 個執行緒相比，並不會完成更快，因為在一個時間點只有 1 個執行緒可以執行 Python：

import os import sys nums =[1 for _ in range(1000000)] chunk_size = len(nums) // 10 readers = [] while nums: chunk, nums = nums[:chunk_size], nums[chunk_size:] reader, writer = os.pipe() if os.fork(): readers.append(reader) # Parent. else: subtotal = 0 for i in chunk: # Intentionally slow code. subtotal += i print('subtotal %d' % subtotal) os.write(writer, str(subtotal).encode()) sys.exit(0) # Parent. total = 0 for reader in readers: subtotal = int(os.read(reader, 1000).decode()) total += subtotal print("Total: %d" % total)

12345678910111213141516171819202122232425262728

import osimport sysnums=[1for_inrange(1000000)]chunk_size=len(nums)// 10readers=[]whilenums:chunk,nums=nums[:chunk_size],nums[chunk_size:]reader,writer=os.pipe()ifos.fork():readers.append(reader)# Parent.else:subtotal=0foriin 相關推薦 深入理解 GIL：如何寫出高效能及執行緒安全的 Python 程式碼 6歲時，我有一個音樂盒。我上緊發條，音樂盒頂上的芭蕾舞女演員就會旋轉起來，同時，內部裝置發出“一閃一閃亮晶晶，滿天都是小星星”的叮鈴聲。那玩意兒肯定俗氣透了，但我喜歡那個音樂盒，我想知道它的工作原理是什麼。後來我拆開了，才看到它裡面一個簡單的裝置，機身內部鑲嵌著一個拇指大小的金 深入理解Java虛擬機器學習筆記3-執行緒安全和鎖優化 併發處理是壓榨計算機運算能力最有力的工具。 1.執行緒安全 當多個執行緒訪問一個物件時，如果不用考慮這些執行緒執行時環境下排程和交替執行，也不需要進行額外的同步，或者在呼叫方進行任何其他的協調操作，呼叫這個物件的行為都可以獲取正確的結果，那麼這個物件是執行緒安全的。 2 深入理解java虛擬機器----第十三章執行緒安全與鎖優化 這一部分和java併發程式設計實戰中講的很多東西一樣，所以可以對照著看。 13.1 概述 對於這部分的主題“高效併發”來講，首先需要保證併發的正確性，然後在此基礎上實現高效。本章先從如何保證併發的正確性和如何實現執行緒安全講起。 13.2 執行緒安全 當多個執行緒訪問一個物件時，如果 深入理解通過Collections將集合轉換為執行緒安全類集合 List集合： List<String> list=new ArrayList<String>();list.add("a");list.add("b");list.add(" 深入理解Java：類載入機制及反射  說明：本文乃學習整理參考而來. 一、Java類載入機制 1．概述        Class檔案由類裝載器裝載後，在JVM中將形成一份描述Class結構的元資訊物件，通過該元資訊物件可以獲知Class的結構資訊：如建構函式，屬性和方法等，Java允許使用者藉由這個Class相關的元資訊物件間接呼 深入理解Java虛擬機器讀書筆記9----執行緒完全與鎖優化 九 執行緒完全與鎖優化   1 Java語言中的執行緒完全         ---執行緒安全：當多個執行緒訪問一個物件時，如果不用考慮這些執行緒在執行時環境下的排程和交替執行，也不需要進行額外的同步，或者在呼叫方進行任何其 高效能的執行緒安全單例——Java基礎語法系列 大家都知道，一般實現單例有兩種寫法： 餓漢式 和 懶漢式， 餓漢式是執行緒安全的，在編譯期間已完成初始化，載入到了記憶體裡。 懶漢式一般寫法是非執行緒安全的， 那懶漢式的執行緒安全單例應該如何實現呢，以及如何寫出低耗能的執行緒安全單例呢 ？ 單例實現關鍵點 建構函式私有， 面試題剖析：單例設計模式執行緒安全問題 本文作者：黃海燕，叩丁狼高階講師。原創文章，轉載請註明出處。 1. volatile 關鍵字 1.1 volatile 關鍵字作用： 在百度百科擷取的描述如下： 叩丁狼教育.png 說明volatile 關鍵字作用作用有兩點： 防止指令重 List set map特點及執行緒安全與否 感謝：http://blog.csdn.net/u011084603/article/details/49108585 List特點：元素有放入順序，元素可重複  Map特點：元素按鍵值對儲存，無放入順序  Set特點：元素無放入順序，元素不可重複（注意：元素雖然無放 linux多執行緒程式設計(C)：訊號量實現的執行緒安全佇列 用訊號量實現的執行緒安全佇列。 簡單有用的示例程式， 比起互斥量的實現在多執行緒時效率更好。 cir_queue.h /* * \File * cir_queue.h * \Brief * circular queue */#ifndef __CIR_QUEUE_H_ Java高併發程式設計學習筆記（三）：Java記憶體模型和執行緒安全 文章目錄 原子性 有序性 可見性 – 編譯器優化 – 硬體優化(如寫吸收，批操作) Java虛擬機器層面的可見性 Happen-Before規則（先行發生） 程式順序原則: volat 【設計模式】單例模式的絕對單例及執行緒安全 1. 餓漢模式 /** * 餓漢模式 * @author 鄭海鵬 * @since 2015年7月6日 */ public class Singleton { private st 關於struts2 的單例和多例及執行緒安全的問題 我知道struts 2的Action是多例項的並非單例，也就是每次請求產生一個Action的物件。原因是：struts 2的Action中包含資料，例如你在頁面填寫的資料就會包含在Action的成員變數裡面。如果Action是單例項的話，這些資料在多執行緒的環境下就會相互影 C++中的單例模式（懶漢模式、餓漢模式及執行緒安全問題） 1 教科書裡的單例模式 　　我們都很清楚一個簡單的單例模式該怎樣去實現：建構函式宣告為private或protect防止被外部函式例項化，內部儲存一個private static的類指標儲存唯一的例項，例項的動作由一個public的類方法代勞，該方法也返回單例類唯一的例 如何退出當前執行緒及執行緒安全 退出當前執行緒的程式碼 -(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{ // 建立執行緒     NSThread *thread =[[NSThre 【高併發】面試官問我：為什麼區域性變數是執行緒安全的？ ## 寫在前面 > 相信很多小夥伴都知道區域性變數是執行緒安全的，那你知道為什麼區域性變數是執行緒安全的嗎？ ## 前言 多個執行緒同時訪問共享變數時，會導致併發問題。那麼，如果將變數放在方法內部，是不是還會存在併發問題呢？如果不存在併發問題，那麼為什麼不會存在併發問題呢？ ## 著名的斐波那契 深入理解Java：類加載機制及反射 指定 請求 image vm虛擬機 常量池 使用 元素 靜態 創建 一、Java類加載機制 1．概述 Class文件由類裝載器裝載後，在JVM中將形成一份描述Class結構的元信息對象，通過該元信息對象可以獲知Class的結構信息：如構造函數，屬性和方法等，J 優化SQL查詢：怎樣寫出高效能SQL語句 1、 首先要搞明白什麼叫執行計劃？ 執行計劃是資料庫根據SQL語句和相關表的統計資訊作出的一個查詢方案，這個方案是由查詢優化器自動分析產生的，比如一條SQL語句如果用來從一個 10萬條記錄的表中查1條記錄，那查詢優化器會選擇“索引查詢”方式，如果該表進行了歸檔，當前只剩下5000條記錄了 第十五節：深入理解async和await的作用及各種適用場景和用法 一. 同步VS非同步 1.   同步 VS 非同步 VS 多執行緒 同步方法：呼叫時需要等待返回結果，才可以繼續往下執行業務 非同步方法：呼叫時無須等待返回結果，可以繼續往下執行業務 開啟新執行緒：在主執行緒之外開啟一個新的執行緒去執行業務 同步方法和非 《深入理解SPARK：核心思想與原始碼分析》——SparkContext的初始化（仲篇）——SparkUI、環境變數及排程 《深入理解Spark：核心思想與原始碼分析》一書第一章的內容請看連結《第1章 環境準備》 《深入理解Spark：核心思想與原始碼分析》一書第二章的內容請看連結《第2章 SPARK設計理念與基本架構》 由於本書的第3章內容較多，所以打算分別開闢四篇隨筆分別展現。 本文展現第3章第二部分的內容：