Python 子直譯器與獨立 GIL:為何把一把鎖拆開要花十年?

在 Python GIL 30 年演進史與 Python 非同步 20 年演進史中,我們看過 CPython 如何面對單一全域直譯器鎖(GIL)的限制:非同步協程解決了高並行 I/O 等待,而 PEP 703 則嘗試拆掉 GIL,讓多執行緒直接共享記憶體。

但拆掉 GIL 的代價不小。為了保護每個物件,Free-threading 必須引入偏向參考計數、執行緒安全記憶體池與物件級臨界區,不僅增加底層複雜度,也帶來約 1% 至 8% 的單執行緒效能損失(依 CPU 平台而異;Python 3.13 早期實驗版曾因暫時停用 3.11 引入的「特化直譯器」動態指令加速機制,降速高達約 40%)。

為了在保留 GIL 單執行緒極速的同時用滿多核 CPU,核心開發者 Eric Snow 自 2014 年推動的路線給出了不同答案:不拆掉鎖,而是把鎖的範圍從「整個作業系統行程」縮小到「單一直譯器」。這項近十年的重構於 Python 3.12 以 PEP 684(Per-Interpreter GIL) 實作於 C-API,並在 Python 3.14 透過 PEP 734 進入標準函式庫 concurrent.interpreters。


1997 年就有的子直譯器,為何二十五年來無法平行?

子直譯器(Sub-interpreters)並非 Python 3.12 才出現的新機制——C-API 早在 1997 年的 Python 1.5 就提供了 Py_NewInterpreter() 與 Py_EndInterpreter()。

這項機制最初是為了在單一行程內隔離命名空間,而非追求多核平行。典型情境是 Apache 上的 mod_python 與 mod_wsgi:在同一個 Worker 行程裡託管多個 Python 網站,既能共享 CPython 動態函式庫的程式碼區段以節省常駐記憶體(RSS),又能讓各網站擁有獨立的 sys.modules 與全域變數。

然而,若想開多條執行緒分別在不同子直譯器裡跑 CPU 密集運算,就會撞上同一道牆:Python 3.11 以前,GIL 綁在作業系統行程上,而非直譯器上。

Python 3.11 以前:所有子直譯器爭奪同一把行程級 GIL

  1. Process-Wide GIL
    1. Main Interp[Thread 1]
    1. Sub-Interp 1[Thread 2]
    1. Sub-Interp 2[Thread 3]

在舊架構中,GIL 是定義在 Python/ceval.c(後封裝進 _PyRuntimeState)的全域鎖。無論建立多少個子直譯器、產生多少條作業系統執行緒(pthread),所有執行緒在執行位元組碼前都必須搶同一把 GIL。

只要主直譯器的 Thread 1 正在算數,Sub-Interpreter 1 的 Thread 2 就會阻塞在條件變數上,多核完全排隊循序執行。

散落的全域靜態變數:把一把鎖拆開為何要十年?

既然問題出在共用同一把鎖,為什麼不直接幫每個子直譯器各配一把 GIL?因為 CPython 數十萬行 C 原始程式碼裡,到處都是預設「全行程只有一把鎖」而寫下的 C 語言 static 全域靜態變數。

一旦讓兩個子直譯器在不同 CPU 核心上同時跑起來,這些沒隔離的共用結構就會立刻撞車:

全域靜態結構未隔離時的多核競爭後果
小整數快取(Small Integer Cache)快取 -5 至 256 的整數供全行程共用;兩直譯器同時加減參考計數(Py_INCREF/Py_DECREF)會引發資料競爭
字串駐留表(Interned String Dictionary)變數名稱與短字串快取於全域字典;兩直譯器同時解析程式碼並寫入同名字串會損毀底層雜湊桶
記憶體池配置器(PyMalloc)管理 Arena、Pool 與 Block 自由鏈結串列的全域指標(如 usedpools)無鎖防護,引發記憶體損毀
內建型別物件PyLong_Type、PyUnicode_Type 等內建型別為靜態結構體,各直譯器同時加減其參考計數或更新內部方法查詢快取時會互相覆蓋
垃圾回收器(GC)分代 GC 雙向環狀鏈結串列全行程僅一條;一端掃描時另一端配置或銷毀物件會導致指標斷裂並 Segfault

要實現「一機一鎖」,就得先把這數千個散落在角落的靜態變數連根拔起。這正是 Eric Snow 從 2014 年啟動多核計畫後,耗時近十年才走完的底層清理工程。


PEP 684 的三層狀態拆解:把家當搬回各自的直譯器

清理完靜態變數後,PEP 684 將 CPython 執行期重構為嚴格的三層狀態階層(Three-Tier State Hierarchy),把原本放在行程頂層的家當全部搬進個別直譯器裡。

  1. Layer 1: _PyRuntimeState (Process Global)OS Signals, Interpreter List, Global rwmutex
    1. Layer 2: InterpState AOwn GIL & Own GC;Own obmalloc & Cache
    2. Layer 3: ThreadState 1Call Stack & Frame
    1. Layer 2: InterpState BOwn GIL & Own GC;Own obmalloc & Cache
    2. Layer 3: ThreadState 2Call Stack & Frame

在這套階層下,行程全域層(_PyRuntimeState) 退居幕後,主要保留作業系統訊號路由(如將 SIGINT 統一交給主直譯器處理)與活動直譯器串列的生命週期管理;底下再由執行緒層(PyThreadState) 各自保存單一作業系統執行緒的呼叫堆疊與例外上下文。

撐起多核平行的關鍵,是中間的直譯器層(PyInterpreterState)。原本散落在行程頂層的執行引擎家當——包含專屬 GIL、獨立記憶體池(obmalloc)、分代垃圾回收器(gc),以及 sys.modules、builtins、小整數快取與字串駐留表——全部下放為直譯器私有。

這意味著記憶體配置與垃圾回收的「世界暫停(Stop-the-World)」徹底局部化:當直譯器 A 觸發循環垃圾回收時,只會暫停直譯器 A 內部的執行緒,跑在另一顆核心上的直譯器 B 照常全速運轉;同時 C-API 也保留了共用 GIL 的傳統設定模式,讓舊版 mod_wsgi 等嵌入式應用維持向下相容。


為什麼子直譯器不能直接共享物件?參考計數與不朽物件

既然多個子直譯器都在同一個作業系統行程裡,為什麼不能直接傳遞 Python 物件指標,省下複製資料的功夫?

答案在 Python 最基礎的記憶體機制:在 CPython 裡,連「讀取」物件都會觸發記憶體寫入。

參考計數的快取行彈跳

寫下一行最簡單的指派語句 x = None 時,CPython 底層必須執行 Py_INCREF(Py_None) 將參考計數加 1;變數離開作用域時再執行 Py_DECREF 減 1。

各直譯器的 GIL 只能約束內部執行緒,直譯器 A 的 GIL 完全管不到直譯器 B。當兩者在不同 CPU 核心上同時運作時,一旦跨直譯器傳遞物件指標,原本受單一 GIL 保護的參考計數就會同時被兩邊修改,立刻撞上兩層硬體瓶頸:

  1. 非原子加減的資料競爭:一般的 ob_refcnt++ 在 CPU 底層會拆成「讀取、加一、寫回」三道指令。兩顆核心同時加減同一個物件的參考計數,計數就會算錯,導致記憶體提早釋放而崩潰,或永遠無法回收。
  2. 快取行彈跳(Cache-Line Bouncing):就算把參考計數全換成 CPU 原子指令(如 x86 的 LOCK XADD),只要兩顆核心頻繁修改同一個物件的 ob_refcnt,該物件所在的 64 位元組快取行(Cache Line)就必須根據快取一致性協定(MESI),在兩顆核心的 L1/L2 快取之間不斷作廢與同步。匯流排同步的延遲,會直接抵消多核平行帶來的加速效果。

因此,只要物件的參考計數會變動,就不能跨直譯器直接共享指標。每個子直譯器必須嚴格隔離各自的動態堆積(Heap),直譯器 A 建立的 list 或 dict 只能由直譯器 A 的記憶體池與 GC 管理。

PEP 683 不朽物件:把參考計數釘死

若每個子直譯器都各自建立 None、True、False 等不變的基礎常數,會浪費大量記憶體與啟動時間;但若要跨直譯器共用,又必須避免參考計數寫入引發快取行彈跳。

為此,Python 3.12 同步引入了 PEP 683(Immortal Objects,不朽物件),把編譯期就確定的唯讀核心單例「釘死」參考計數,放回全域供所有直譯器安全共享;執行期會動態變化的物件與快取表,才維持直譯器各自私有。

不朽物件的做法很直接:把核心常數的 ob_refcnt 設為高位元標記的哨兵常數(64 位元系統上初始值約 32 億,只要超過 2312^{31} 門檻即視為不朽)。當 Py_INCREF 與 Py_DECREF 檢查到這個不朽標記時,直接跳過加減,完全不寫入記憶體。

因為沒有任何記憶體寫入,None、True、False、Ellipsis、空元組 ()、常用 ASCII 單字元字串與全域內建型別所在的快取行,在所有 CPU 核心的 L1 快取中都能一直保持唯讀共享(Shared)狀態。子直譯器既能安全共用這些基礎單例,又不會引發半點快取行彈跳。


Python 3.14 實戰:跨直譯器怎麼傳資料?

動態物件不能共享指標,那多個子直譯器要怎麼協同運算?

這套架構採用了類似 Actor 模型或 Go 語言 CSP 的哲學:不透過共享記憶體來通訊,而是透過通訊來共享資料。Python 3.12 先開放底層 C-API,到了 Python 3.14,PEP 734 正式將 concurrent.interpreters 與 InterpreterPoolExecutor 納入標準函式庫。

1. 標準函式庫介面與 InterpreterPoolExecutor

最省力的用法是直接替換 concurrent.futures 的執行池。InterpreterPoolExecutor 是 ThreadPoolExecutor 的子類別,三者實作同一組 Executor 介面:

from concurrent.futures import InterpreterPoolExecutor

def cpu_bound_worker(chunk: list[int]) -> int:
    return sum(x * x for x in chunk)

if __name__ == "__main__":
    data_chunks = [list(range(i, i + 1_000_000)) for i in range(4)]

    # 建立 4 個各自擁有獨立 GIL 的子直譯器平行運算
    with InterpreterPoolExecutor(max_workers=4) as executor:
        results = list(executor.map(cpu_bound_worker, data_chunks))
        print("計算結果總和:", sum(results))

若需要更細緻的生命週期控制與雙向通訊,則可直接使用 concurrent.interpreters 建立子直譯器與跨直譯器佇列(Queue):

from concurrent import interpreters

interp = interpreters.create()
queue = interpreters.create_queue()

# 將佇列綁定至子直譯器的 __main__ 命名空間
interp.prepare_main({"task_queue": queue})
queue.put(10)

interp.exec("""
import math
data = task_queue.get()
task_queue.put(math.factorial(data))
""")

print(queue.get())  # 輸出: 3628800
interp.close()

2. 底層如何安全搬運資料?

跨直譯器傳遞資料時,concurrent.interpreters 會在底層先把資料從來源直譯器的 PyObject 剝離成純 C 語言原始資料,再由目標直譯器的記憶體池重建為全新 Python 物件。開發者可用 interpreters.is_shareable(obj) 檢查物件是否可跨直譯器共享,底層依資料型別採取不同傳遞策略:

資料類別跨直譯器傳遞機制記憶體與通訊特性
可共享型別(Shareable)
None、布林值、int、float、str、bytes 以及元素皆可共享的 tuple
剝離為純 C 原始資料傳入,接收端用自身記憶體池重建 PyObject無需通用序列化;傳遞字串時僅傳遞內部字元緩衝區指標(含 kind 與長度資訊),接收端各自配置新字串
可變容器與複雜物件
list、dict 等可變物件
不可共享且不可 pickle 的物件拋出 NotShareableError;佇列與執行池預設退回 pickle 複製副本全程在同一行程記憶體內完成,無作業系統 Pipe 或 Socket 開銷
大型二進位緩衝區
memoryview、連續二進位資料
透過 Buffer Protocol 跨直譯器直接共享底層純 C 連續記憶體(Raw Buffer)零複製;不共享 Python 標頭與參考計數,避開快取行彈跳,來源端追蹤引用防提前釋放

最大痛點:為什麼 NumPy 等 C 擴充還不能直接用?

純 Python 程式碼在子直譯器裡維持原生速度,但當你在子直譯器裡寫下 import numpy 或載入許多第三方套件時,卻可能直接撞上 ImportError: module <name> does not support loading in subinterpreters 錯誤。

問題的根源,跟前面提到的 CPython 核心一模一樣:傳統 C 擴充模組自己也寫了一堆 C 語言 static 全域變數。

早期 Python C 擴充採用「單階段初始化(Single-Phase Initialization)」,模組習慣把快取字典、計數器或自訂型別直接宣告成 C 檔案裡的 static 全域變數。

如果兩個子直譯器同時載入這種模組,它們在 C 層級讀寫的是同一塊行程資料區段,立刻引發資料競爭;一旦其中一個子直譯器關閉並釋放型別關聯資源,另一個仍在執行的子直譯器碰到該型別就會當場 Segfault。

為此,Python 在 PEP 489(Multi-Phase Extension Module Initialization) 定義了多階段初始化規範,並由 PEP 684 擴充支援標記,要求 C 擴充做到三件事才能安全支援子直譯器:

  1. 放棄 C 靜態變數:把模組所有狀態放進專屬結構體,每個子直譯器 import 時動態配置各自的一份。
  2. 改用堆積型別(Heap Types):自訂型別改在堆積上動態建立,讓型別生命週期跟著個別直譯器走。
  3. 明確宣告支援標記:在模組槽位定義中明確標註支援獨立 GIL(Py_MOD_PER_INTERPRETER_GIL_SUPPORTED)。

IMPORTANT

預設攔截未改寫的 C 擴充:為了防止老舊 C 擴充在背景破壞記憶體,具備獨立 GIL 的子直譯器採取白名單防護——只要模組未依 PEP 489 實作多階段初始化並宣告 Py_MOD_PER_INTERPRETER_GIL_SUPPORTED 支援標記,在子直譯器中 import 就會被 CPython 直接攔截並拋出 ImportError。這保護了行程穩定,但也代表高度仰賴複雜 C/C++ 擴充的科學計算與機器學習套件,還需要時間逐一完成狀態隔離改造。


三大平行路線對決:Multiprocessing、子直譯器與 Free-Threading 怎麼選?

走到 Python 3.14,後端與資料工程師面對 CPU 密集型任務時,手上有三種架構截然不同的平行工具。它們沒有誰徹底淘汰誰,而是各自卡住了不同的工程取捨點:

比較項目多行程(multiprocessing)子直譯器(Per-Interpreter GIL)自由執行緒(Free-Threading)
GIL 與執行單元多個 OS 行程,每行程一把 GIL單一行程多執行緒,每直譯器一把 GIL單一行程多執行緒,移除 GIL
單執行緒效能0% 損失(原生速度)0% 損失(原生速度)約慢 1%–8%(依平台而異;3.13 早期曾慢約 40%)
記憶體模型實體隔離的行程定址空間同一行程位址,Python 堆積隔離同一行程位址,完全共享堆積
記憶體與啟動成本高(行程啟動慢、CoW 易失效)低(共用行程空間與不朽物件,但需各自 import)最低(僅建立執行緒,共用單一堆積)
跨執行單元的資料傳遞OS IPC(Pipe/Socket + Pickle)行程內 C 資料重建/Buffer 零複製直接共享物件指標(零通訊成本)
資料競爭風險無無(不共享可變 Python 物件)高(需自行加鎖防範 Race Condition)
C 擴充相容性100% 相容所有既有套件需符合 PEP 489 並宣告支援需相容 Free-threaded(否則自動退回 GIL)
崩潰隔離性高(子行程崩潰不影響主行程)低(C 層崩潰會拖垮整個行程)低(C 層崩潰會拖垮整個行程)

1. 為什麼子直譯器能改善 multiprocessing 的痛點?

過去繞過 GIL 的標準答案是 multiprocessing,但它在大型後端服務裡有兩個長年痛點:

子直譯器雖然仍需各自 import 業務模組、建立獨立的命名空間,但它直接避開了作業系統的 fork 與 CoW 機制。

所有子直譯器以行程內多執行緒的形式,共用動態函式庫的程式碼區段(.text)與全域不朽物件,各自需要多少記憶體一清二楚,不會像多行程那樣因為分頁寫入複製而突然暴增;跨直譯器通訊也不必進出作業系統核心,搭配 Buffer Protocol 還能直接零複製讀取原始資料。

2. 子直譯器 vs Free-Threading:隔離安全與共享彈性的取捨

既然 Python 3.14 已經正式支援 python3.14t(Free-threading),為什麼還需要子直譯器?

實務評估選用時,只需把握三條明確邊界:

TIP

三條實務評估邊界:

  • Free-Threading:需要多執行緒頻繁讀寫同一份大型可變狀態(如記憶體內大型圖結構或共用快取樹)。
  • Multiprocessing:重度仰賴尚未支援 PEP 489 的傳統 C 擴充,或需要行程級防崩潰隔離。
  • 子直譯器(Per-Interpreter GIL):任務邊界清楚的純 Python CPU 密集運算與分段資料管線,兼顧原生單執行緒速度與直譯器間的記憶體隔離。