對 Python 中 GIL 的一點理解
GIL(Global Interpreter Lock)，全局解釋器鎖，是 CPython 為了避免在多線程環境下造成 Python 解釋器內部數據的不一致而引入的一把鎖，讓 Python 中的多個線程交替運行，避免競爭。
需要說明的是 GIL 不是 Python 語言規範的一部分，只是由於 CPython 實現的需要而引入的，其他的實現如 Jython 和 PyPy 是沒有 GIL 的。那麼為什麼 CPython 需要 GIL 呢，下面我們就來一探究竟（基於 CPython 3.10.4）。
為什麼需要 GIL
GIL 本質上是一把鎖，學過操作系統的同學都知道鎖的引入是為了避免並發訪問造成數據的不一致。CPython 中有很多定義在函數外面的全局變量，比如內存管理中的 usable_arenas 和 usedpools，如果多個線程同時申請內存就可能同時修改這些變量，造成數據錯亂。另外 Python 的垃圾回收機制是基於引用計數的，所有對象都有一個 ob_refcnt 字段表示當前有多少變量會引用當前對象，變量賦值、參數傳遞等操作都會增加引用計數，退出作用域或函數返回會減少引用計數。同樣地，如果有多個線程同時修改同一個對象的引用計數，就有可能使 ob_refcnt 與真實值不同，可能會造成內存泄漏，不會被使用的對象得不到回收，更嚴重可能會回收還在被引用的對象，造成 Python 解釋器崩潰。
GIL 的實現
CPython 中 GIL 的定義如下
struct _gil_runtime_state {
unsigned long interval; // 請求 GIL 的線程在 interval 毫秒後還沒成功，就會向持有 GIL 的線程發出釋放信號
_Py_atomic_address last_holder; // GIL 上一次的持有線程，強制切換線程時會用到
_Py_atomic_int locked; // GIL 是否被某個線程持有
unsigned long switch_number; // GIL 的持有線程切換了多少次
// 條件變量和互斥鎖，一般都是成對出現
PyCOND_T cond;
PyMUTEX_T mutex;
// 條件變量，用於強制切換線程
PyCOND_T switch_cond;
PyMUTEX_T switch_mutex;
};
最本質的是 mutex 保護的 locked 字段，表示 GIL 當前是否被持有，其他字段是為了優化 GIL 而被用到的。線程申請 GIL 時會調用 take_gil() 方法，釋放 GIL時 調用 drop_gil() 方法。為了避免飢餓現象，當一個線程等待了 interval 毫秒（默認是 5 毫秒）還沒申請到 GIL 的時候，就會主動向持有 GIL 的線程發出信號，GIL 的持有者會在恰當時機檢查該信號，如果發現有其他線程在申請就會強制釋放 GIL。這裡所說的恰當時機在不同版本中有所不同，早期是每執行 100 條指令會檢查一次，在 Python 3.10.4 中是在條件語句結束、循環語句的每次循環體結束以及函數調用結束的時候才會去檢查。
申請 GIL 的函數 take_gil() 簡化後如下
static void take_gil(PyThreadState *tstate)
{
...
// 申請互斥鎖
MUTEX_LOCK(gil->mutex);
// 如果 GIL 空閑就直接獲取
if (!_Py_atomic_load_relaxed(&gil->locked)) {
goto _ready;
}
// 嘗試等待
while (_Py_atomic_load_relaxed(&gil->locked)) {
unsigned long saved_switchnum = gil->switch_number;
unsigned long interval = (gil->interval >= 1 ? gil->interval : 1);
int timed_out = 0;
COND_TIMED_WAIT(gil->cond, gil->mutex, interval, timed_out);
if (timed_out && _Py_atomic_load_relaxed(&gil->locked) && gil->switch_number == saved_switchnum) {
SET_GIL_DROP_REQUEST(interp);
}
}
_ready:
MUTEX_LOCK(gil->switch_mutex);
_Py_atomic_store_relaxed(&gil->locked, 1);
_Py_ANNOTATE_RWLOCK_ACQUIRED(&gil->locked, /*is_write=*/1);
if (tstate != (PyThreadState*)_Py_atomic_load_relaxed(&gil->last_holder)) {
_Py_atomic_store_relaxed(&gil->last_holder, (uintptr_t)tstate);
++gil->switch_number;
}
// 喚醒強制切換的線程主動等待的條件變量
COND_SIGNAL(gil->switch_cond);
MUTEX_UNLOCK(gil->switch_mutex);
if (_Py_atomic_load_relaxed(&ceval2->gil_drop_request)) {
RESET_GIL_DROP_REQUEST(interp);
}
else {
COMPUTE_EVAL_BREAKER(interp, ceval, ceval2);
}
...
// 釋放互斥鎖
MUTEX_UNLOCK(gil->mutex);
}
整個函數體為了保證原子性，需要在開頭和結尾分別申請和釋放互斥鎖 gil->mutex。如果當前 GIL 是空閑狀態就直接獲取 GIL，如果不空閑就等待條件變量 gil->cond interval 毫秒（不小於 1 毫秒），如果超時並且期間沒有發生過 GIL 切換就將 gil_drop_request 置位，請求強制切換 GIL 持有線程，否則繼續等待。一旦獲取 GIL 成功需要更新 gil->locked、gil->last_holder 和 gil->switch_number 的值，喚醒條件變量 gil->switch_cond，並且釋放互斥鎖 gil->mutex。
釋放 GIL 的函數 drop_gil() 簡化後如下
static void drop_gil(struct _ceval_runtime_state *ceval, struct _ceval_state *ceval2,
PyThreadState *tstate)
{
...
if (tstate != NULL) {
_Py_atomic_store_relaxed(&gil->last_holder, (uintptr_t)tstate);
}
MUTEX_LOCK(gil->mutex);
_Py_ANNOTATE_RWLOCK_RELEASED(&gil->locked, /*is_write=*/1);
// 釋放 GIL
_Py_atomic_store_relaxed(&gil->locked, 0);
// 喚醒正在等待 GIL 的線程
COND_SIGNAL(gil->cond);
MUTEX_UNLOCK(gil->mutex);
if (_Py_atomic_load_relaxed(&ceval2->gil_drop_request) && tstate != NULL) {
MUTEX_LOCK(gil->switch_mutex);
// 強制等待一次線程切換才被喚醒，避免飢餓
if (((PyThreadState*)_Py_atomic_load_relaxed(&gil->last_holder)) == tstate)
{
assert(is_tstate_valid(tstate));
RESET_GIL_DROP_REQUEST(tstate->interp);
COND_WAIT(gil->switch_cond, gil->switch_mutex);
}
MUTEX_UNLOCK(gil->switch_mutex);
}
}
首先在 gil->mutex 的保護下釋放 GIL，然後喚醒其他正在等待 GIL 的線程。在多 CPU 的環境下，當前線程在釋放 GIL 後有更高的概率重新獲得 GIL，為了避免對其他線程造成飢餓，當前線程需要強制等待條件變量 gil->switch_cond，只有在其他線程獲取 GIL 的時候當前線程才會被喚醒。
幾點說明
GIL 優化
受 GIL 約束的代碼不能並行執行，降低了整體性能，為了盡量降低性能損失，Python 在進行 IO 操作或不涉及對象訪問的密集 CPU 計算的時候，會主動釋放 GIL，減小了 GIL 的粒度，比如
- 讀寫文件
- 網絡訪問
- 加密數據/壓縮數據
所以嚴格來說，在單進程的情況下，多個 Python 線程時可能同時執行的，比如一個線程在正常運行，另一個線程在壓縮數據。
用戶數據的一致性不能依賴 GIL
GIL 是為了維護 Python 解釋器內部變量的一致性而產生的鎖，用戶數據的一致性不由 GIL 負責。雖然 GIL 在一定程度上也保證了用戶數據的一致性，比如 Python 3.10.4 中不涉及跳轉和函數調用的指令都會在 GIL 的約束下原子性的執行，但是數據在業務邏輯上的一致性需要用戶自己加鎖來保證。
下面的代碼用兩個線程模擬用戶集碎片得獎
from threading import Thread
def main():
stat = {"piece_count": 0, "reward_count": 0}
t1 = Thread(target=process_piece, args=(stat,))
t2 = Thread(target=process_piece, args=(stat,))
t1.start()
t2.start()
t1.join()
t2.join()
print(stat)
def process_piece(stat):
for i in range(10000000):
if stat["piece_count"] % 10 == 0:
reward = True
else:
reward = False
if reward:
stat["reward_count"] += 1
stat["piece_count"] += 1
if __name__ == "__main__":
main()
假設用戶每集齊 10 個碎片就能得到一次獎勵，每個線程收集了 10000000 個碎片，應該得到 9999999 個獎勵（最後一次沒有計算），總共應該收集 20000000 個碎片，得到 1999998 個獎勵，但是在我電腦上一次運行結果如下
{'piece_count': 20000000, 'reward_count': 1999987}
總的碎片數量與預期一致，但是獎勵數量卻少了 12 個。碎片數量正確是因為在 Python 3.10.4 中，stat["piece_count"] += 1 是在 GIL 約束下原子性執行的。由於每次循環結束都可能切換執行線程，那麼可能線程 t1 在某次循環結束時將 piece_count 加到 100，但是在下次循環開始模 10 判斷前，Python 解釋器切換到線程 t2 執行，t2 將 piece_count 加到 101，那麼就會錯過一次獎勵。
總結
GIL 是 CPython 為了在多線程環境下為了維護解釋器內部數據一致性而引入的，為了儘可能降低 GIL 的粒度，在 IO 操作和不涉及對象訪問的 CPU 計算時會主動釋放 GIL。最後，用戶數據的一致性不能依賴 GIL，可能需要用戶使用 Lock 或 RLock() 來保證數據的原子性訪問。
參考文檔
//realpython.com/python-gil/
//github.com/python/cpython/commit/074e5ed974be65fbcfe75a4c0529dbc53f13446f
//mail.python.org/pipermail/python-dev/2009-October/093321.html
//www.backblaze.com/blog/the-python-gil-past-present-and-future/
