模組四：CPython 內部機制 on Tarragon

3.1 PyObject 與物件模型

Tue, 20 Jan 2026 00:00:00 +0000

Python 中「一切皆物件」不只是一句口號，而是 CPython 實現的核心設計。理解 PyObject 是深入 Python 內部的第一步。

先備知識

進階系列模組二：元編程
基本的 C 語言知識（結構體、指標）

本章目標

學完本章後，你將能夠：

理解 PyObject 結構
理解參考計數的工作原理
解釋「一切皆物件」的實現方式
觀察物件的記憶體佈局

【原理層】一切皆物件

什麼是「一切皆物件」？

在 Python 中，所有東西都是物件：

 1# 數字是物件
 2x = 42
 3print(type(x))        # 
 4print(x.__class__)    # 
 5print(x.bit_length()) # 6（呼叫方法）
 6
 7# 函式是物件
 8def hello():
 9    pass
10print(type(hello))    # 
11print(hello.__name__) # hello
12
13# 類別是物件
14class MyClass:
15    pass
16print(type(MyClass))  # 
17
18# 甚至 type 本身也是物件
19print(type(type))     #

PyObject 結構

在 C 語言層面，所有 Python 物件都基於 PyObject 結構：

1// CPython 原始碼中的定義（簡化版）
2typedef struct _object {
3    Py_ssize_t ob_refcnt;  // 參考計數
4    PyTypeObject *ob_type; // 型別指標
5} PyObject;

每個 Python 物件在記憶體中至少包含這兩個欄位：

1┌─────────────────────────────────────┐
2│           PyObject                   │
3├─────────────────────────────────────┤
4│  ob_refcnt (參考計數)    8 bytes    │
5│  ob_type   (型別指標)    8 bytes    │
6├─────────────────────────────────────┤
7│  ... 物件特定的資料 ...              │
8└─────────────────────────────────────┘

變長物件：PyVarObject

對於長度可變的物件（如 list、str），使用 PyVarObject：

1typedef struct {
2    PyObject ob_base;
3    Py_ssize_t ob_size;  // 元素數量
4} PyVarObject;

1┌─────────────────────────────────────┐
2│         PyVarObject                  │
3├─────────────────────────────────────┤
4│  ob_refcnt (參考計數)    8 bytes    │
5│  ob_type   (型別指標)    8 bytes    │
6│  ob_size   (元素數量)    8 bytes    │
7├─────────────────────────────────────┤
8│  ... 元素資料 ...                    │
9└─────────────────────────────────────┘

【設計層】參考計數

工作原理

Python 使用參考計數來追蹤物件的使用：

 1import sys
 2
 3a = [1, 2, 3]
 4print(sys.getrefcount(a))  # 2（a 本身 + getrefcount 的參數）
 5
 6b = a  # 增加參考
 7print(sys.getrefcount(a))  # 3
 8
 9del b  # 減少參考
10print(sys.getrefcount(a))  # 2

參考計數的增減時機

 1# 增加參考計數的操作
 2x = obj          # 賦值
 3container.append(obj)  # 加入容器
 4func(obj)        # 作為參數傳遞
 5
 6# 減少參考計數的操作
 7del x            # 刪除變數
 8x = other        # 重新賦值
 9container.remove(obj)  # 從容器移除
10函式返回         # 區域變數離開作用域

參考計數的優缺點

優點	缺點
即時回收	無法處理循環參考
可預測的記憶體使用	每次操作都要更新計數
簡單易理解	多執行緒下需要鎖（GIL 的原因之一）

【實作層】觀察物件

使用 id() 觀察記憶體位址

 1a = [1, 2, 3]
 2b = a
 3c = [1, 2, 3]
 4
 5print(id(a))  # 140234567890112
 6print(id(b))  # 140234567890112（同一物件）
 7print(id(c))  # 140234567890176（不同物件）
 8
 9print(a is b)  # True
10print(a is c)  # False
11print(a == c)  # True（值相等）

小整數快取

CPython 對 -5 到 256 的整數進行快取：

 1a = 256
 2b = 256
 3print(a is b)  # True（同一物件）
 4
 5a = 257
 6b = 257
 7print(a is b)  # False（不同物件）
 8
 9# 但在同一行的情況可能會被編譯器優化
10a, b = 257, 257
11print(a is b)  # True（編譯時優化）

字串駐留（String Interning）

簡單的字串會被自動駐留：

 1a = "hello"
 2b = "hello"
 3print(a is b)  # True（駐留）
 4
 5a = "hello world"
 6b = "hello world"
 7print(a is b)  # False（含空格，不駐留）
 8
 9# 手動駐留
10import sys
11a = sys.intern("hello world")
12b = sys.intern("hello world")
13print(a is b)  # True

使用 ctypes 觀察記憶體

 1import ctypes
 2import sys
 3
 4def get_refcount(obj_id):
 5    """直接從記憶體讀取參考計數"""
 6    return ctypes.c_long.from_address(obj_id).value
 7
 8a = [1, 2, 3]
 9obj_id = id(a)
10
11print(f"sys.getrefcount: {sys.getrefcount(a)}")
12print(f"ctypes 直接讀取: {get_refcount(obj_id)}")
13# 注意：sys.getrefcount 會多 1（因為參數傳遞）

觀察物件大小

 1import sys
 2
 3# 基本物件大小
 4print(sys.getsizeof(None))      # 16
 5print(sys.getsizeof(True))      # 28
 6print(sys.getsizeof(0))         # 28
 7print(sys.getsizeof(1))         # 28
 8print(sys.getsizeof(10**100))   # 72（大整數）
 9
10# 容器大小（不包含元素）
11print(sys.getsizeof([]))        # 56
12print(sys.getsizeof([1, 2, 3])) # 88
13print(sys.getsizeof({}))        # 64
14
15# 注意：getsizeof 不遞迴計算
16nested = [[1, 2], [3, 4]]
17print(sys.getsizeof(nested))    # 只計算外層 list

【深入】PyTypeObject

型別物件的結構

每個型別（int、str、list 等）都是 PyTypeObject 的實例：

 1// 簡化版
 2typedef struct _typeobject {
 3    PyObject_VAR_HEAD
 4    const char *tp_name;       // 型別名稱
 5    Py_ssize_t tp_basicsize;   // 基本大小
 6    Py_ssize_t tp_itemsize;    // 元素大小（變長物件）
 7
 8    // 方法槽（slots）
 9    destructor tp_dealloc;     // 解構函式
10    reprfunc tp_repr;          // __repr__
11    hashfunc tp_hash;          // __hash__
12    // ... 更多方法槽
13} PyTypeObject;

在 Python 中觀察型別資訊

 1# 型別的基本資訊
 2print(int.__name__)       # int
 3print(int.__basicsize__)  # 28（64-bit 系統）
 4
 5# 方法解析順序
 6class A: pass
 7class B(A): pass
 8class C(B): pass
 9
10print(C.__mro__)
11# (, , , )
12
13# 型別的型別
14print(type(int))    # 
15print(type(type))   # （type 是自己的實例）

為什麼 is 比 == 快？

 1# is 只比較記憶體位址（一個指標比較）
 2# == 需要呼叫 __eq__ 方法（可能很複雜）
 3
 4import timeit
 5
 6a = [1, 2, 3]
 7b = a
 8c = [1, 2, 3]
 9
10# is 比較（非常快）
11print(timeit.timeit('a is b', globals=globals(), number=1000000))
12# 約 0.02 秒
13
14# == 比較（需要比較內容）
15print(timeit.timeit('a == c', globals=globals(), number=1000000))
16# 約 0.05 秒

【實戰】效能影響

避免不必要的物件建立

 1# 不好：每次迭代都建立新的 tuple
 2for i in range(1000):
 3    point = (i, i * 2)
 4
 5# 好：如果結構固定，考慮使用 __slots__ 的類別
 6class Point:
 7    __slots__ = ['x', 'y']
 8    def __init__(self, x, y):
 9        self.x = x
10        self.y = y
11
12# 或者使用 namedtuple
13from collections import namedtuple
14Point = namedtuple('Point', ['x', 'y'])

使用物件池

 1# 對於頻繁建立的小物件，考慮重複使用
 2class ObjectPool:
 3    def __init__(self, factory, max_size=100):
 4        self._factory = factory
 5        self._pool = []
 6        self._max_size = max_size
 7
 8    def acquire(self):
 9        if self._pool:
10            return self._pool.pop()
11        return self._factory()
12
13    def release(self, obj):
14        if len(self._pool) < self._max_size:
15            self._pool.append(obj)
16
17# 使用
18pool = ObjectPool(list)
19lst = pool.acquire()
20lst.extend([1, 2, 3])
21# 使用完畢
22lst.clear()
23pool.release(lst)

思考題

為什麼 CPython 選擇 -5 到 256 作為小整數快取的範圍？
如果參考計數是 Python 物件的核心，那多執行緒時會發生什麼問題？
None 是單例，這是如何實現的？

實作練習

寫一個函式，計算一個巢狀資料結構的「真實」記憶體使用量
使用 ctypes 觀察 list 物件的內部結構
實驗不同大小的整數的 is 行為

延伸閱讀

下一章：記憶體管理與垃圾回收

3.2 記憶體管理與垃圾回收

Tue, 20 Jan 2026 00:00:00 +0000

Python 的記憶體管理結合了參考計數和分代垃圾回收。理解這些機制有助於寫出更高效的程式碼。

先備知識

3.1 PyObject 與物件模型

本章目標

學完本章後，你將能夠：

理解參考計數的限制
理解分代垃圾回收的原理
使用 __slots__ 優化記憶體
使用 tracemalloc 分析記憶體使用

【原理層】記憶體模型

Stack vs Heap

Python 的記憶體分為兩個主要區域：

 1┌─────────────────────────────────────┐
 2│              Stack                   │
 3│  ┌─────────────────────────────────┐│
 4│  │ 變數名稱 → 指向 Heap 的指標      ││
 5│  │ a ──────→ [指標]                ││
 6│  │ b ──────→ [指標]                ││
 7│  └─────────────────────────────────┘│
 8└─────────────────────────────────────┘
 9                 │
10                 ▼
11┌─────────────────────────────────────┐
12│              Heap                    │
13│  ┌─────────────────────────────────┐│
14│  │ PyObject: [1, 2, 3]             ││
15│  │ PyObject: "hello"               ││
16│  │ PyObject: 42                    ││
17│  └─────────────────────────────────┘│
18└─────────────────────────────────────┘

Stack：儲存變數名稱和指標（參考）
Heap：儲存實際的 Python 物件

Python 的記憶體分配器

CPython 使用分層的記憶體分配器：

 1┌─────────────────────────────────────┐
 2│     Python 物件分配器               │
 3│     (PyObject_Malloc)               │
 4├─────────────────────────────────────┤
 5│     Python 記憶體分配器             │
 6│     (PyMem_Malloc)                  │
 7├─────────────────────────────────────┤
 8│     C 標準函式庫                    │
 9│     (malloc)                        │
10├─────────────────────────────────────┤
11│     作業系統                        │
12└─────────────────────────────────────┘

對於小於 512 bytes 的物件，Python 使用自己的分配器來減少系統呼叫。

【設計層】循環參考問題

參考計數的限制

參考計數無法處理循環參考：

 1import gc
 2
 3class Node:
 4    def __init__(self, name):
 5        self.name = name
 6        self.ref = None
 7
 8# 建立循環參考
 9a = Node("A")
10b = Node("B")
11a.ref = b
12b.ref = a
13
14# 刪除外部參考
15del a
16del b
17
18# 此時 A 和 B 仍互相參考，參考計數都是 1
19# 但它們已經無法被存取了（垃圾）

1刪除前：
2外部 ─→ A ←──→ B ←─ 外部
3        refcnt=2  refcnt=2
4
5刪除後：
6        A ←──→ B
7        refcnt=1  refcnt=1
8        （無法被存取，但參考計數不為 0）

分代垃圾回收

為了解決循環參考，Python 使用分代垃圾回收：

 1import gc
 2
 3# 查看 GC 統計
 4print(gc.get_count())  # (700, 10, 0) - 各代的物件數
 5
 6# 三個世代（Python 3.12 以前）
 7# Generation 0: 新物件
 8# Generation 1: 存活過一次 GC 的物件
 9# Generation 2: 存活過多次 GC 的物件
10
11# Python 3.12+ 改為四個世代
12# Young generation (1 代)
13# Old generations (2 代)
14# Permanent generation (永久)

GC 觸發時機

 1import gc
 2
 3# 查看閾值
 4print(gc.get_threshold())  # (700, 10, 10)
 5
 6# 意義：
 7# - 當 Generation 0 有 700 個物件時，觸發 Gen 0 GC
 8# - 當 Gen 0 GC 執行 10 次後，觸發 Gen 1 GC
 9# - 當 Gen 1 GC 執行 10 次後，觸發 Gen 2 GC
10
11# 手動觸發 GC
12gc.collect()
13
14# 設定閾值
15gc.set_threshold(1000, 15, 15)

【實作層】記憶體優化

使用 slots

__slots__ 可以顯著減少物件的記憶體使用：

 1import sys
 2
 3class WithoutSlots:
 4    def __init__(self, x, y):
 5        self.x = x
 6        self.y = y
 7
 8class WithSlots:
 9    __slots__ = ['x', 'y']
10
11    def __init__(self, x, y):
12        self.x = x
13        self.y = y
14
15obj1 = WithoutSlots(1, 2)
16obj2 = WithSlots(1, 2)
17
18print(sys.getsizeof(obj1))  # 48
19print(sys.getsizeof(obj2))  # 48（但沒有 __dict__）
20
21# 實際差異在 __dict__
22print(sys.getsizeof(obj1.__dict__))  # 104
23# obj2 沒有 __dict__

為什麼 `slots` 省記憶體？

 1沒有 __slots__：
 2┌─────────────────────────┐
 3│ PyObject header (16 B)  │
 4│ __dict__ 指標 (8 B)      │
 5│ __weakref__ 指標 (8 B)   │
 6│ __dict__ → { 'x': 1,    │
 7│              'y': 2 }   │
 8│            （額外 100+ B）│
 9└─────────────────────────┘
10
11有 __slots__：
12┌─────────────────────────┐
13│ PyObject header (16 B)  │
14│ x (8 B)                 │
15│ y (8 B)                 │
16└─────────────────────────┘

slots 的限制

 1class Base:
 2    __slots__ = ['x']
 3
 4class Derived(Base):
 5    __slots__ = ['y']  # 不能與父類別重複
 6
 7    def __init__(self):
 8        self.x = 1
 9        self.y = 2
10        # self.z = 3  # 錯誤！沒有 __dict__
11
12# 如果需要動態屬性，加入 '__dict__'
13class Flexible:
14    __slots__ = ['x', '__dict__']

使用弱參考

弱參考不增加參考計數，適合用於快取：

 1import weakref
 2
 3class ExpensiveObject:
 4    def __init__(self, value):
 5        self.value = value
 6
 7# 建立物件和弱參考
 8obj = ExpensiveObject(42)
 9weak_ref = weakref.ref(obj)
10
11print(weak_ref())  # 
12print(weak_ref().value)  # 42
13
14# 刪除強參考
15del obj
16
17print(weak_ref())  # None（物件已被回收）

使用 WeakValueDictionary 實作快取

 1import weakref
 2
 3class Cache:
 4    def __init__(self):
 5        self._cache = weakref.WeakValueDictionary()
 6
 7    def get(self, key, factory):
 8        value = self._cache.get(key)
 9        if value is None:
10            value = factory()
11            self._cache[key] = value
12        return value
13
14cache = Cache()
15
16def create_expensive():
17    return ExpensiveObject(100)
18
19obj = cache.get('key1', create_expensive)
20# 當 obj 不再被使用時，快取會自動清理

【實作層】記憶體分析工具

使用 tracemalloc

 1import tracemalloc
 2
 3# 開始追蹤
 4tracemalloc.start()
 5
 6# 執行程式碼
 7data = [i ** 2 for i in range(10000)]
 8more_data = {str(i): i for i in range(10000)}
 9
10# 取得記憶體快照
11snapshot = tracemalloc.take_snapshot()
12
13# 顯示前 10 個記憶體使用最多的位置
14top_stats = snapshot.statistics('lineno')
15for stat in top_stats[:10]:
16    print(stat)
17
18# 比較兩個快照
19tracemalloc.start()
20snapshot1 = tracemalloc.take_snapshot()
21
22# 執行更多程式碼
23big_list = list(range(100000))
24
25snapshot2 = tracemalloc.take_snapshot()
26diff = snapshot2.compare_to(snapshot1, 'lineno')
27
28for stat in diff[:5]:
29    print(stat)

使用 gc 模組除錯

 1import gc
 2
 3# 啟用除錯
 4gc.set_debug(gc.DEBUG_LEAK)
 5
 6# 找出無法回收的物件
 7gc.collect()
 8print(gc.garbage)  # 無法回收的物件列表
 9
10# 取得所有被追蹤的物件
11all_objects = gc.get_objects()
12print(f"被追蹤的物件數量: {len(all_objects)}")
13
14# 找出特定類別的實例
15class MyClass:
16    pass
17
18instances = [obj for obj in gc.get_objects() if isinstance(obj, MyClass)]
19print(f"MyClass 實例數量: {len(instances)}")

檢測記憶體洩漏

 1import gc
 2import tracemalloc
 3
 4def find_memory_leak():
 5    tracemalloc.start()
 6
 7    # 記錄初始狀態
 8    gc.collect()
 9    snapshot1 = tracemalloc.take_snapshot()
10
11    # 執行可能洩漏的程式碼
12    for _ in range(1000):
13        suspicious_function()
14
15    # 記錄最終狀態
16    gc.collect()
17    snapshot2 = tracemalloc.take_snapshot()
18
19    # 比較
20    diff = snapshot2.compare_to(snapshot1, 'lineno')
21
22    print("記憶體增長最多的位置：")
23    for stat in diff[:10]:
24        print(stat)

【實戰】常見記憶體問題

問題 1：大量小物件

 1# 不好：建立大量小物件
 2class Point:
 3    def __init__(self, x, y):
 4        self.x = x
 5        self.y = y
 6
 7points = [Point(i, i) for i in range(1000000)]
 8
 9# 好：使用 __slots__
10class Point:
11    __slots__ = ['x', 'y']
12    def __init__(self, x, y):
13        self.x = x
14        self.y = y
15
16# 更好：使用 NumPy（如果是數值資料）
17import numpy as np
18points = np.zeros((1000000, 2))

問題 2：循環參考

 1# 不好：物件間的循環參考
 2class Parent:
 3    def __init__(self):
 4        self.children = []
 5
 6class Child:
 7    def __init__(self, parent):
 8        self.parent = parent
 9        parent.children.append(self)
10
11# 好：使用弱參考
12import weakref
13
14class Child:
15    def __init__(self, parent):
16        self.parent = weakref.ref(parent)
17        parent.children.append(self)

問題 3：全域變數累積

 1# 不好：全域快取無限增長
 2_cache = {}
 3
 4def process(key, value):
 5    if key not in _cache:
 6        _cache[key] = expensive_compute(value)
 7    return _cache[key]
 8
 9# 好：使用 LRU cache
10from functools import lru_cache
11
12@lru_cache(maxsize=1000)
13def process(key, value):
14    return expensive_compute(value)

思考題

為什麼 Python 需要同時使用參考計數和垃圾回收？只用其中一種不行嗎？
__slots__ 為什麼不能用於繼承自內建型別的類別？
在什麼情況下應該手動呼叫 gc.collect()？

實作練習

使用 tracemalloc 分析一個現有程式的記憶體使用
將一個使用大量物件的程式改用 __slots__ 優化
使用 WeakValueDictionary 實作一個自動清理的快取

延伸閱讀

上一章：PyObject 與物件模型 下一章：Bytecode 與虛擬機

3.3 Bytecode 與虛擬機

Tue, 20 Jan 2026 00:00:00 +0000

Python 先把原始碼編譯成 bytecode，再由虛擬機執行。理解這個過程有助於優化程式碼效能。

先備知識

3.2 記憶體管理與垃圾回收

本章目標

學完本章後，你將能夠：

理解 Python 的編譯流程
使用 dis 模組分析 bytecode
從 bytecode 角度理解效能差異
了解 Python 3.11+ 的效能優化

【原理層】Python 的執行流程

編譯與執行

 1原始碼 (.py)
 2    │
 3    ▼
 4┌─────────────┐
 5│   詞法分析   │ ← 將原始碼分解成 tokens
 6│   (Lexer)   │
 7└─────────────┘
 8    │
 9    ▼
10┌─────────────┐
11│   語法分析   │ ← 建立抽象語法樹 (AST)
12│   (Parser)  │
13└─────────────┘
14    │
15    ▼
16┌─────────────┐
17│   編譯器    │ ← 將 AST 編譯成 bytecode
18│  (Compiler) │
19└─────────────┘
20    │
21    ▼
22Bytecode (.pyc)
23    │
24    ▼
25┌─────────────┐
26│   虛擬機    │ ← 執行 bytecode
27│    (VM)     │
28└─────────────┘
29    │
30    ▼
31  執行結果

.pyc 檔案與 pycache

 1# 當你 import 一個模組時，Python 會：
 2# 1. 檢查 __pycache__ 中是否有對應的 .pyc 檔案
 3# 2. 如果沒有或過期，重新編譯
 4# 3. 將編譯結果存入 __pycache__
 5
 6# 檔案命名格式：
 7# module.cpython-312.pyc
 8# module.cpython-313.pyc
 9
10# 手動編譯
11import py_compile
12py_compile.compile('script.py')
13
14# 編譯整個目錄
15import compileall
16compileall.compile_dir('my_package/')

程式碼物件（Code Object）

編譯後的 bytecode 儲存在程式碼物件中：

 1def example(x, y):
 2    z = x + y
 3    return z * 2
 4
 5code = example.__code__
 6
 7print(code.co_name)       # example
 8print(code.co_varnames)   # ('x', 'y', 'z')
 9print(code.co_consts)     # (None, 2)
10print(code.co_code)       # b'|\x00|\x01\x17\x00}\x02|\x02d\x01\x14\x00S\x00'

【設計層】Stack-based 虛擬機

工作原理

Python 虛擬機是 stack-based（堆疊式）：

1執行 x + y：
2
31. LOAD_FAST 0 (x)    Stack: [x]
42. LOAD_FAST 1 (y)    Stack: [x, y]
53. BINARY_ADD         Stack: [x+y]

 1import dis
 2
 3def add(x, y):
 4    return x + y
 5
 6dis.dis(add)
 7# 輸出：
 8#   2           0 RESUME                   0
 9#
10#   3           2 LOAD_FAST                0 (x)
11#               4 LOAD_FAST                1 (y)
12#               6 BINARY_OP                0 (+)
13#              10 RETURN_VALUE

常見 Bytecode 指令

指令	說明
LOAD_FAST	載入區域變數
LOAD_GLOBAL	載入全域變數
LOAD_CONST	載入常數
STORE_FAST	儲存區域變數
BINARY_OP	二元運算
CALL	呼叫函式
RETURN_VALUE	返回值
JUMP_FORWARD	向前跳躍
POP_JUMP_IF_FALSE	條件跳躍

【實作層】使用 dis 模組

基本用法

1import dis
2
3# 反組譯函式
4def factorial(n):
5    if n <= 1:
6        return 1
7    return n * factorial(n - 1)
8
9dis.dis(factorial)

分析控制流程

 1import dis
 2
 3def loop_example():
 4    total = 0
 5    for i in range(10):
 6        total += i
 7    return total
 8
 9dis.dis(loop_example)
10# 可以看到 FOR_ITER、JUMP_BACKWARD 等指令

比較不同實現

 1import dis
 2
 3# 版本 1：使用迴圈
 4def sum_loop(n):
 5    total = 0
 6    for i in range(n):
 7        total += i
 8    return total
 9
10# 版本 2：使用內建函式
11def sum_builtin(n):
12    return sum(range(n))
13
14print("=== 迴圈版本 ===")
15dis.dis(sum_loop)
16
17print("\n=== 內建函式版本 ===")
18dis.dis(sum_builtin)
19
20# 內建函式版本的 bytecode 更少，而且 sum() 是 C 實現

【效能】從 Bytecode 理解效能

為什麼區域變數比全域變數快？

 1import dis
 2
 3global_var = 10
 4
 5def use_global():
 6    return global_var + 1
 7
 8def use_local():
 9    local_var = 10
10    return local_var + 1
11
12dis.dis(use_global)
13# LOAD_GLOBAL 0 (global_var)  ← 需要查找全域命名空間
14
15dis.dis(use_local)
16# LOAD_FAST 0 (local_var)     ← 直接用索引存取

1LOAD_GLOBAL: 需要在 globals() dict 中查找
2LOAD_FAST:   直接用索引存取陣列（O(1)）

為什麼 list comprehension 比 for 迴圈快？

 1import dis
 2
 3def for_loop():
 4    result = []
 5    for i in range(100):
 6        result.append(i * 2)
 7    return result
 8
 9def list_comp():
10    return [i * 2 for i in range(100)]
11
12dis.dis(for_loop)
13# 更多指令，包括 LOAD_METHOD (append)、CALL
14
15dis.dis(list_comp)
16# 使用特殊的 LIST_APPEND 指令，更高效

字串連接的效能

 1import dis
 2
 3def concat_plus():
 4    s = ""
 5    for i in range(10):
 6        s = s + str(i)
 7    return s
 8
 9def concat_join():
10    return "".join(str(i) for i in range(10))
11
12# plus 版本每次都建立新字串
13# join 版本一次性建立

【深入】Python 3.11+ 的優化

Specializing Adaptive Interpreter

Python 3.11 引入了自適應特化直譯器：

1# 針對常見模式進行優化
2# 例如：如果一個函式總是接收 int 參數
3
4def add(a, b):
5    return a + b
6
7# 前幾次呼叫：使用通用的 BINARY_OP
8# 多次呼叫後：特化為 BINARY_OP_ADD_INT

查看特化指令

1import dis
2
3def example():
4    x = 1
5    y = 2
6    return x + y
7
8# 使用 adaptive=True 查看特化指令
9dis.dis(example, adaptive=True)

內聯快取（Inline Caching）

1# Python 3.11+ 在 bytecode 中包含快取空間
2# 用於儲存運行時資訊
3
4def get_attr(obj):
5    return obj.value
6
7# 第一次呼叫：查找 'value' 屬性
8# 之後：使用快取的位置資訊

【實戰】效能調校

使用 bytecode 分析熱點

 1import dis
 2import timeit
 3
 4def version_a(data):
 5    total = 0
 6    for item in data:
 7        total = total + item
 8    return total
 9
10def version_b(data):
11    total = 0
12    for item in data:
13        total += item
14    return total
15
16# 比較 bytecode
17print("=== version_a ===")
18dis.dis(version_a)
19print("\n=== version_b ===")
20dis.dis(version_b)
21
22# 實際測量
23data = list(range(1000))
24print(timeit.timeit(lambda: version_a(data), number=10000))
25print(timeit.timeit(lambda: version_b(data), number=10000))
26# 結果相近，因為 total = total + item 和 total += item
27# 在 Python 中編譯成相同的 bytecode

避免不必要的屬性查找

 1import dis
 2
 3class MyClass:
 4    def __init__(self):
 5        self.value = 0
 6
 7    def slow_method(self):
 8        for i in range(100):
 9            self.value += i  # 每次都要查找 self.value
10
11    def fast_method(self):
12        value = self.value  # 快取到區域變數
13        for i in range(100):
14            value += i
15        self.value = value
16
17dis.dis(MyClass.slow_method)
18# 迴圈內有 LOAD_FAST (self) + LOAD_ATTR (value)
19
20dis.dis(MyClass.fast_method)
21# 迴圈內只有 LOAD_FAST (value)

使用 slots 加速屬性存取

 1import dis
 2
 3class WithoutSlots:
 4    def __init__(self, x):
 5        self.x = x
 6
 7class WithSlots:
 8    __slots__ = ['x']
 9    def __init__(self, x):
10        self.x = x
11
12def access_without_slots(obj):
13    return obj.x
14
15def access_with_slots(obj):
16    return obj.x
17
18# bytecode 相同，但運行時 __slots__ 更快
19# 因為不需要查找 __dict__

【參考】完整 Bytecode 列表

Python 3.12 的主要指令類別：

 1載入指令：
 2  LOAD_CONST, LOAD_FAST, LOAD_GLOBAL, LOAD_NAME, LOAD_ATTR
 3
 4儲存指令：
 5  STORE_FAST, STORE_GLOBAL, STORE_NAME, STORE_ATTR
 6
 7運算指令：
 8  BINARY_OP, UNARY_NEGATIVE, UNARY_NOT
 9
10跳躍指令：
11  JUMP_FORWARD, JUMP_BACKWARD, POP_JUMP_IF_TRUE, POP_JUMP_IF_FALSE
12
13函式相關：
14  CALL, RETURN_VALUE, PUSH_NULL
15
16迭代相關：
17  GET_ITER, FOR_ITER
18
19容器相關：
20  BUILD_LIST, BUILD_TUPLE, BUILD_MAP, LIST_APPEND

思考題

為什麼 Python 選擇 stack-based VM 而不是 register-based VM？
.pyc 檔案可以跨平台使用嗎？為什麼？
JIT 編譯器（如 PyPy）與 CPython 的直譯器有什麼根本差異？

實作練習

使用 dis 比較 map() 和 list comprehension 的 bytecode
寫一個簡單的 bytecode 分析工具，計算指令數量
研究 Python 3.11 和 3.12 的 bytecode 變化

延伸閱讀

上一章：記憶體管理與垃圾回收 下一章：GIL 與執行緒模型

3.4 GIL 與執行緒模型

Tue, 20 Jan 2026 00:00:00 +0000

GIL（Global Interpreter Lock）是 CPython 中最具爭議的設計之一。本章深入探討 GIL 的歷史、實現，以及 Python 3.13+ Free-threading 的技術細節。

先備知識

本章目標

學完本章後，你將能夠：

理解 GIL 存在的歷史原因
理解 GIL 的釋放時機
理解 Free-threading 的實現挑戰
做出正確的並行策略選擇

【原理層】為什麼需要 GIL？

歷史背景

GIL 是 1992 年 Python 初創時的設計決策：

1當時的考量：
21. 單核 CPU 是主流
32. 簡化記憶體管理（參考計數）
43. 簡化 C 擴展開發
54. 避免細粒度鎖的複雜性

參考計數與執行緒安全

GIL 主要保護參考計數操作：

 1// 沒有 GIL 時，這個操作不是原子的
 2Py_INCREF(obj);
 3// 展開後：
 4// 1. 讀取 ob_refcnt
 5// 2. 加 1
 6// 3. 寫回 ob_refcnt
 7
 8// 如果兩個執行緒同時執行，可能會：
 9// Thread 1: 讀取 refcnt = 1
10// Thread 2: 讀取 refcnt = 1
11// Thread 1: 寫入 refcnt = 2
12// Thread 2: 寫入 refcnt = 2  ← 錯誤！應該是 3

GIL 的實現

1// 簡化版的 GIL 結構
2typedef struct {
3    PyMutex mutex;           // 互斥鎖
4    PyThread_type_lock lock; // 執行緒鎖
5    int locked;              // 鎖定狀態
6} _gil_runtime_state;

【設計層】GIL 的釋放時機

自動釋放

GIL 在以下情況會自動釋放：

 1# 1. I/O 操作
 2f = open('file.txt', 'r')  # 釋放 GIL
 3content = f.read()          # 釋放 GIL
 4
 5# 2. sleep
 6import time
 7time.sleep(1)  # 釋放 GIL
 8
 9# 3. 某些 C 擴展操作
10import numpy as np
11result = np.dot(a, b)  # NumPy 可能釋放 GIL
12
13# 4. 定期釋放（每 N 個 bytecode 指令）
14# Python 3.2+ 預設約每 5ms 檢查一次

檢查間隔

1import sys
2
3# 查看切換間隔（秒）
4print(sys.getswitchinterval())  # 0.005（5ms）
5
6# 設定切換間隔
7sys.setswitchinterval(0.001)  # 1ms

C 擴展中手動釋放 GIL

 1// C 擴展可以明確釋放 GIL
 2static PyObject* compute_intensive(PyObject* self, PyObject* args) {
 3    // 釋放 GIL
 4    Py_BEGIN_ALLOW_THREADS
 5
 6    // 這裡的程式碼可以並行執行
 7    do_heavy_computation();
 8
 9    // 重新獲取 GIL
10    Py_END_ALLOW_THREADS
11
12    Py_RETURN_NONE;
13}

【實驗】測量 GIL 的影響

CPU 密集任務

 1import threading
 2import time
 3
 4def cpu_intensive(n):
 5    """純 Python CPU 密集計算"""
 6    total = 0
 7    for i in range(n):
 8        total += i * i
 9    return total
10
11def benchmark(func, args, num_threads):
12    threads = []
13    start = time.perf_counter()
14
15    for _ in range(num_threads):
16        t = threading.Thread(target=func, args=args)
17        threads.append(t)
18        t.start()
19
20    for t in threads:
21        t.join()
22
23    return time.perf_counter() - start
24
25n = 5_000_000
26
27# 單執行緒
28time_1 = benchmark(cpu_intensive, (n,), 1)
29print(f"1 執行緒: {time_1:.3f}s")
30
31# 多執行緒（受 GIL 限制）
32time_4 = benchmark(cpu_intensive, (n,), 4)
33print(f"4 執行緒: {time_4:.3f}s")
34
35# 結果：多執行緒可能更慢（執行緒切換開銷）

I/O 密集任務

 1import threading
 2import time
 3import urllib.request
 4
 5def io_intensive(url):
 6    """I/O 密集操作"""
 7    try:
 8        with urllib.request.urlopen(url, timeout=5) as f:
 9            return len(f.read())
10    except:
11        return 0
12
13urls = ["https://example.com"] * 10
14
15# 單執行緒
16start = time.perf_counter()
17for url in urls:
18    io_intensive(url)
19time_sequential = time.perf_counter() - start
20print(f"序列: {time_sequential:.3f}s")
21
22# 多執行緒
23start = time.perf_counter()
24threads = [threading.Thread(target=io_intensive, args=(url,)) for url in urls]
25for t in threads:
26    t.start()
27for t in threads:
28    t.join()
29time_parallel = time.perf_counter() - start
30print(f"並行: {time_parallel:.3f}s")
31
32# 結果：多執行緒明顯更快（I/O 時釋放 GIL）

【深入】Free-threading 技術細節

Biased Reference Counting

Python 3.13+ Free-threading 使用「偏向參考計數」解決多執行緒問題：

 1傳統參考計數：
 2┌─────────────────────────────────────┐
 3│  ob_refcnt = 2                      │
 4│  每次操作都需要原子操作或鎖         │
 5└─────────────────────────────────────┘
 6
 7偏向參考計數：
 8┌─────────────────────────────────────┐
 9│  local_refcnt[thread_id] = 1        │  ← 每個執行緒有自己的計數
10│  local_refcnt[thread_id] = 1        │
11│  shared_refcnt = 0                  │  ← 共享計數
12└─────────────────────────────────────┘
13
14優點：
15- 大多數操作只需更新區域計數（無鎖）
16- 只有跨執行緒參考才需要更新共享計數

延遲參考計數

 1# Free-threading 中的優化策略
 2
 3# 對於不朽物件（immortal objects）
 4# 如 None、True、False、小整數
 5# 完全跳過參考計數
 6
 7# 對於局部物件
 8# 使用區域計數，無需同步
 9
10# 只有跨執行緒共享的物件
11# 才需要使用原子操作

記憶體模型變化

 1傳統 CPython（有 GIL）：
 2┌──────────────────────────────────────────┐
 3│  Thread 1  │  Thread 2  │  Thread 3      │
 4│     ↓            ↓            ↓          │
 5│     └────────────┼────────────┘          │
 6│                  ↓                       │
 7│               [ GIL ]                    │
 8│                  ↓                       │
 9│        [ Python Interpreter ]            │
10│                  ↓                       │
11│          [ 共享記憶體 ]                  │
12└──────────────────────────────────────────┘
13
14Free-threaded CPython：
15┌──────────────────────────────────────────┐
16│  Thread 1  │  Thread 2  │  Thread 3      │
17│     ↓            ↓            ↓          │
18│  [Local]     [Local]     [Local]         │
19│  State       State       State           │
20│     ↓            ↓            ↓          │
21│     └────────────┼────────────┘          │
22│                  ↓                       │
23│     [ 原子操作 / 鎖 / 無鎖資料結構 ]     │
24│                  ↓                       │
25│          [ 共享記憶體 ]                  │
26└──────────────────────────────────────────┘

【實戰】Free-threading 程式設計

檢查執行環境

 1import sys
 2
 3def check_environment():
 4    """檢查 Free-threading 環境"""
 5    try:
 6        gil_enabled = sys._is_gil_enabled()
 7        print(f"GIL 啟用: {gil_enabled}")
 8        return not gil_enabled
 9    except AttributeError:
10        print("傳統 Python（有 GIL）")
11        return False
12
13is_free_threaded = check_environment()

執行緒安全的程式設計

 1import threading
 2
 3# 不安全：共享可變狀態
 4counter = 0
 5
 6def unsafe_increment():
 7    global counter
 8    for _ in range(100000):
 9        counter += 1  # 競爭條件！
10
11# 安全：使用鎖
12counter = 0
13lock = threading.Lock()
14
15def safe_increment():
16    global counter
17    for _ in range(100000):
18        with lock:
19            counter += 1
20
21# 更好：使用原子操作或不可變資料
22from collections import Counter
23from concurrent.futures import ThreadPoolExecutor
24
25def better_approach(data_chunk):
26    """每個執行緒處理自己的資料，最後合併"""
27    local_count = 0
28    for item in data_chunk:
29        local_count += process(item)
30    return local_count
31
32with ThreadPoolExecutor() as executor:
33    results = executor.map(better_approach, data_chunks)
34    total = sum(results)

適應性程式碼

 1import sys
 2
 3def compute(data):
 4    """根據環境選擇策略"""
 5    free_threaded = getattr(sys, '_is_gil_enabled', lambda: True)() == False
 6
 7    if free_threaded:
 8        # 可以安全使用多執行緒
 9        return parallel_compute_threading(data)
10    else:
11        # 使用多進程或保持單執行緒
12        return parallel_compute_multiprocess(data)

【選擇指南】並行策略

決策流程

 1你的任務是什麼類型？
 2│
 3├── I/O 密集（網路、檔案、資料庫）
 4│   └── 使用 threading 或 asyncio
 5│       （GIL 不影響）
 6│
 7└── CPU 密集（計算、處理）
 8    │
 9    ├── 使用 Free-threaded Python (3.13+)?
10    │   ├── 是 → 可以使用 threading
11    │   └── 否 → 選擇以下方案
12    │
13    ├── 可以用 C 擴展？
14    │   └── NumPy、Cython 等（會釋放 GIL）
15    │
16    └── 純 Python？
17        └── 使用 multiprocessing 或 ProcessPoolExecutor

效能比較總結

任務類型	threading (有 GIL)	threading (Free)	multiprocessing
I/O 密集	好	好	過重
CPU 密集	無效	好	好
記憶體共享	簡單	簡單	複雜
啟動成本	低	低	高

【未來】GIL 的發展

路線圖

1Python 3.13 (2024): 實驗性 Free-threading
2Python 3.14 (2025): 正式支援 Free-threading
3Python 3.15/3.16:   可能成為預設
4未來:               GIL 可能完全移除

生態系統遷移

1# 檢查套件是否支援 Free-threading
2# pip index versions package-name
3
4# 主要框架的支援狀態（2025年底）
5# NumPy 2.1+:       支援
6# pandas 2.2+:      支援
7# scikit-learn 1.6+: 支援
8# PyTorch 2.6+:     支援

思考題

如果沒有 GIL，CPython 需要做哪些改變來保證記憶體安全？
為什麼其他 Python 實現（如 Jython、IronPython）沒有 GIL？
Free-threading 的效能損失主要來自哪裡？如何最小化？

實作練習

寫一個程式，測量 GIL 切換間隔對效能的影響
比較 Free-threaded 和傳統 Python 在相同 CPU 密集任務上的效能
將一個使用 multiprocessing 的程式改寫為 Free-threading 版本

延伸閱讀

上一章：Bytecode 與虛擬機 下一模組：模組四：用 C 擴展 Python

4.5 Free-Threading - Python 的真正多執行緒時代

Tue, 20 Jan 2026 00:00:00 +0000

Python 3.13 開始提供實驗性的 Free-threading 支援，Python 3.14 正式將其升級為官方支援功能。這是 Python 歷史上最重要的並行處理改進之一。

什麼是 Free-Threading？

GIL 的歷史與限制

長久以來，CPython 使用 GIL（Global Interpreter Lock）來簡化記憶體管理和 C 擴展的開發。但這也意味著：

1傳統 Python（有 GIL）：
2┌─────────────────────────────────┐
3│  Thread 1  →  執行中             │
4│  Thread 2  →  等待 GIL...        │
5│  Thread 3  →  等待 GIL...        │
6│  Thread 4  →  等待 GIL...        │
7└─────────────────────────────────┘
8   同一時間只有一個執行緒能執行 Python 程式碼

1Free-threaded Python（無 GIL）：
2┌─────────────────────────────────┐
3│  Thread 1  →  執行中  (Core 1)   │
4│  Thread 2  →  執行中  (Core 2)   │
5│  Thread 3  →  執行中  (Core 3)   │
6│  Thread 4  →  執行中  (Core 4)   │
7└─────────────────────────────────┘
8   多個執行緒可以真正並行執行

發展歷程

版本	狀態	PEP
Python 3.13	實驗性支援	PEP 703
Python 3.14	正式支援	PEP 779
Python 3.15/3.16	可能成為預設	待定

安裝與啟用

各平台安裝方式

Windows / macOS

從 python.org 下載安裝程式，選擇「Customize installation」，勾選「Free threaded mode」。

Ubuntu / Debian

1# 使用 deadsnakes PPA
2sudo add-apt-repository ppa:deadsnakes/ppa
3sudo apt update
4sudo apt install python3.13-nogil
5# 或
6sudo apt install python3.14-nogil

安裝後可使用 python3.13t 或 python3.14t 執行。

從原始碼編譯

1./configure --disable-gil
2make -j$(nproc)
3sudo make install

確認安裝

1# 檢查版本資訊
2python3.14t -VV
3# 輸出應包含 "free-threading build"
4
5# 確認 GIL 狀態
6python3.14t -c "import sys; print('GIL enabled:', sys._is_gil_enabled())"
7# 應該輸出：GIL enabled: False

控制 GIL 狀態

1# 強制停用 GIL（即使有不相容模組）
2PYTHON_GIL=0 python3.14t script.py
3
4# 或使用命令列參數
5python3.14t -Xgil=0 script.py
6
7# 強制啟用 GIL（在 free-threaded 版本中）
8python3.14t -Xgil=1 script.py

效能實測數據

以下數據來自多個可信來源（Real Python、CodSpeed、Facebook Benchmarking）：

單執行緒 vs 多執行緒效能

場景	傳統 Python	Free-threaded	差異
單執行緒	1.44s	1.86s	慢 ~30% (3.13)
單執行緒	基準	慢 ~9%	(3.14 改善)
多執行緒 4 核	1.37s	0.39s	快 3.5x
Fibonacci 並行	1377ms	279ms	快 ~5x

關鍵數據

Python 3.13 單執行緒額外負擔：約 40%
Python 3.14 單執行緒額外負擔：約 5-10%（大幅改善）
多執行緒加速比：接近線性擴展（視任務而定）

重點：Free-threading 在單執行緒下有效能損失，但在多執行緒 CPU 密集任務中可獲得顯著加速。

適用場景判斷

適合使用 Free-threading

CPU 密集的並行計算：數學運算、資料處理
可分割的獨立任務：批次處理、平行搜尋
資料科學工作流程：大規模資料轉換
科學計算：模擬、數值分析

不適合使用 Free-threading

單執行緒應用：會有 5-10% 效能損失
I/O 密集任務：傳統 threading 已經足夠
大量使用尚未支援的 C 擴展：可能導致 GIL 被重新啟用
需要穩定性的生產環境：生態系統仍在成熟中

實際範例

範例 1：檢查是否在 Free-threaded 模式

 1import sys
 2
 3def is_free_threaded() -> bool:
 4    """檢查是否在 free-threaded 模式執行"""
 5    try:
 6        return not sys._is_gil_enabled()
 7    except AttributeError:
 8        # Python 3.12 或更早版本沒有這個函式
 9        return False
10
11def get_python_build_info() -> dict:
12    """取得 Python 建置資訊"""
13    return {
14        "version": sys.version,
15        "free_threaded": is_free_threaded(),
16        "gil_enabled": getattr(sys, '_is_gil_enabled', lambda: True)(),
17    }
18
19if __name__ == "__main__":
20    info = get_python_build_info()
21    print(f"Python 版本: {info['version']}")
22    print(f"Free-threaded: {info['free_threaded']}")
23    print(f"GIL 啟用: {info['gil_enabled']}")

範例 2：並行 CPU 計算

 1import threading
 2import time
 3import sys
 4
 5def cpu_intensive(n: int) -> int:
 6    """CPU 密集計算：計算平方和"""
 7    return sum(i * i for i in range(n))
 8
 9def sequential_compute(numbers: list[int]) -> list[int]:
10    """序列計算"""
11    return [cpu_intensive(n) for n in numbers]
12
13def parallel_compute(numbers: list[int]) -> list[int]:
14    """並行計算"""
15    results = [None] * len(numbers)
16
17    def worker(idx: int, n: int):
18        results[idx] = cpu_intensive(n)
19
20    threads = [
21        threading.Thread(target=worker, args=(i, n))
22        for i, n in enumerate(numbers)
23    ]
24
25    for t in threads:
26        t.start()
27    for t in threads:
28        t.join()
29
30    return results
31
32def benchmark():
33    """效能比較"""
34    numbers = [5_000_000] * 4
35
36    # 序列執行
37    start = time.perf_counter()
38    sequential_compute(numbers)
39    sequential_time = time.perf_counter() - start
40
41    # 並行執行
42    start = time.perf_counter()
43    parallel_compute(numbers)
44    parallel_time = time.perf_counter() - start
45
46    print(f"序列執行: {sequential_time:.3f}s")
47    print(f"並行執行: {parallel_time:.3f}s")
48    print(f"加速比: {sequential_time / parallel_time:.2f}x")
49
50    # 在傳統 Python 中，加速比接近 1（無改善）
51    # 在 Free-threaded Python 中，加速比接近 CPU 核心數
52
53if __name__ == "__main__":
54    try:
55        print(f"GIL 啟用: {sys._is_gil_enabled()}")
56    except AttributeError:
57        print("GIL 狀態: 無法檢測（舊版 Python）")
58
59    benchmark()

範例 3：使用 ThreadPoolExecutor

 1from concurrent.futures import ThreadPoolExecutor, as_completed
 2import time
 3import sys
 4
 5def process_chunk(chunk_id: int, size: int) -> dict:
 6    """處理一個資料區塊"""
 7    result = sum(i * i for i in range(size))
 8    return {"chunk_id": chunk_id, "result": result}
 9
10def parallel_process(num_chunks: int = 8, chunk_size: int = 2_000_000):
11    """並行處理多個資料區塊"""
12    start = time.perf_counter()
13
14    with ThreadPoolExecutor(max_workers=num_chunks) as executor:
15        futures = {
16            executor.submit(process_chunk, i, chunk_size): i
17            for i in range(num_chunks)
18        }
19
20        results = []
21        for future in as_completed(futures):
22            chunk_id = futures[future]
23            result = future.result()
24            results.append(result)
25            print(f"Chunk {chunk_id} 完成")
26
27    elapsed = time.perf_counter() - start
28    print(f"\n總耗時: {elapsed:.3f}s")
29    print(f"平均每個 chunk: {elapsed / num_chunks:.3f}s")
30
31    return results
32
33if __name__ == "__main__":
34    try:
35        print(f"Free-threaded 模式: {not sys._is_gil_enabled()}\n")
36    except AttributeError:
37        print("傳統 Python 模式\n")
38
39    parallel_process()

concurrent.interpreters 模組（Python 3.14 新增）

Python 3.14 引入了全新的 concurrent.interpreters 模組，提供了另一種並行方式。

什麼是多解釋器？

多解釋器（Multiple Interpreters）是在同一個進程中運行多個獨立的 Python 直譯器：

1┌─────────────────────────────────────────┐
2│              單一進程                     │
3│  ┌──────────┐  ┌──────────┐             │
4│  │ 解釋器 1  │  │ 解釋器 2  │             │
5│  │ (獨立)   │  │ (獨立)   │             │
6│  │ sys.path │  │ sys.path │  ← 完全隔離  │
7│  │ modules  │  │ modules  │             │
8│  └──────────┘  └──────────┘             │
9└─────────────────────────────────────────┘

基本用法

 1from concurrent.futures import InterpreterPoolExecutor
 2
 3def cpu_task(n: int) -> int:
 4    """在獨立解釋器中執行的任務"""
 5    return sum(i * i for i in range(n))
 6
 7if __name__ == "__main__":
 8    numbers = [1_000_000, 2_000_000, 3_000_000, 4_000_000]
 9
10    # 使用多解釋器池
11    with InterpreterPoolExecutor(max_workers=4) as executor:
12        results = list(executor.map(cpu_task, numbers))
13
14    print(f"結果: {results}")

多解釋器 vs 多進程 vs 多執行緒

特性	threading	multiprocessing	interpreters
隔離程度	共享記憶體	完全隔離	部分隔離
資源消耗	最低	最高	中等
啟動速度	最快	最慢	中等
通訊方式	直接存取	pickle/Queue	pickle
GIL 影響	受限（傳統）/ 無（Free-threaded）	無	無

何時使用多解釋器

需要隔離但不想付出多進程的代價
想要類似 CSP/Actor 模型的並行方式
需要在同一進程中運行不同配置的 Python 環境

已知問題與陷阱

來自 GitHub Issues 的真實案例

1. pathlib 的 race condition（#139001）

1# 在 3.14t 中可能有問題
2from pathlib import Path
3import threading
4
5path = Path("/some/path")
6
7def check_path():
8    # is_dir() 在多執行緒下可能有競爭條件
9    return path.is_dir()

2. click 套件的問題（#136248）

使用 click 套件時，在 free-threaded 模式下可能出現意外行為。

3. buffer interface 的資料競爭（#130977）

使用 memoryview 或其他 buffer interface 時需特別注意。

常見錯誤模式

 1# 錯誤：全域狀態未加鎖保護
 2cache = {}
 3
 4def get_cached(key):
 5    if key not in cache:
 6        cache[key] = expensive_compute(key)  # 競爭條件！
 7    return cache[key]
 8
 9# 正確：使用 Lock 保護
10import threading
11
12cache = {}
13cache_lock = threading.Lock()
14
15def get_cached_safe(key):
16    with cache_lock:
17        if key not in cache:
18            cache[key] = expensive_compute(key)
19        return cache[key]

 1# 錯誤：依賴內建型別的「隱式」執行緒安全
 2results = []
 3
 4def worker(n):
 5    result = compute(n)
 6    results.append(result)  # 在 free-threaded 中可能不安全
 7
 8# 正確：返回結果，由主執行緒收集
 9def worker_safe(n):
10    return compute(n)
11
12with ThreadPoolExecutor() as executor:
13    results = list(executor.map(worker_safe, items))

套件相容性現況（2025 年底）

已完全支援

套件	版本	備註
NumPy	2.1.0+	科學計算基礎
SciPy	1.15.0+	科學計算
pandas	2.2.3+	資料分析
PyTorch	2.6.0+	深度學習
scikit-learn	1.6.0+	機器學習
Pillow	11.0.0+	圖像處理
Matplotlib	3.9.0+	繪圖

部分支援或開發中

cryptography、h5py、polars
aiohttp、multidict、yarl
多個 aio-libs 套件

尚未支援

lxml、cupy 等特定套件
部分 C 擴展模組

追蹤最新狀態：py-free-threading.github.io/tracking

最佳實踐與建議

1. 漸進式採用

 1import sys
 2
 3def main():
 4    # 檢查執行環境
 5    free_threaded = getattr(sys, '_is_gil_enabled', lambda: True)() == False
 6
 7    if free_threaded:
 8        print("使用 Free-threaded 最佳化路徑")
 9        run_parallel_optimized()
10    else:
11        print("使用傳統多進程路徑")
12        run_multiprocess_fallback()

2. 明確使用同步原語

1import threading
2
3# 永遠明確使用 Lock，不要依賴「可能」的執行緒安全
4lock = threading.Lock()
5
6def thread_safe_operation():
7    with lock:
8        # 關鍵區段
9        pass

3. 測試策略

 1# 使用較短的執行緒切換間隔來暴露潛在的競爭條件
 2import sys
 3sys.setswitchinterval(0.0001)  # 測試時使用
 4
 5# 運行大量並行測試
 6import concurrent.futures
 7import random
 8
 9def stress_test(func, iterations=1000):
10    with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
11        futures = [executor.submit(func) for _ in range(iterations)]
12        for f in concurrent.futures.as_completed(futures):
13            f.result()  # 會拋出任何異常

4. 檢查依賴套件相容性

 1def check_dependencies():
 2    """檢查關鍵依賴是否支援 free-threading"""
 3    import importlib.metadata
 4
 5    packages_to_check = ['numpy', 'pandas', 'scikit-learn']
 6    results = {}
 7
 8    for pkg in packages_to_check:
 9        try:
10            version = importlib.metadata.version(pkg)
11            results[pkg] = version
12        except importlib.metadata.PackageNotFoundError:
13            results[pkg] = "未安裝"
14
15    return results

未來展望

路線圖

Python 3.15：預期 Free-threading 將成為可選的預設選項
Python 3.16：可能成為真正的預設建置
長期：GIL 可能完全移除

社群呼籲

「Free-threaded 建置是這個語言的未來。現階段我們需要更多來自真實工作流程的回饋報告。」 — Quansight Labs

如果你正在使用 Free-threaded Python，歡迎：

回報問題到 Python Bug Tracker
參與 py-free-threading Discord 討論
測試你的套件並提交相容性報告

思考題

為什麼 Free-threading 在單執行緒下會有效能損失？這個損失從 40% 降到 9% 是如何達成的？
什麼情況下應該使用 InterpreterPoolExecutor 而不是 ThreadPoolExecutor？
如果你的程式依賴一個尚未支援 Free-threading 的套件，有什麼替代方案？

實作練習

寫一個程式，比較在傳統 Python 和 Free-threaded Python 下的多執行緒效能差異
使用 InterpreterPoolExecutor 實作一個簡單的任務佇列系統
為一個現有的單執行緒程式添加 Free-threading 支援，並處理執行緒安全問題

先備知識

入門系列並行處理 - threading、multiprocessing 基礎

上一章：GIL 與執行緒模型 下一模組：模組五：用 C 擴展 Python

模組四：CPython 內部機制 on Tarragon

3.1 PyObject 與物件模型

先備知識

本章目標

【原理層】一切皆物件

什麼是「一切皆物件」？

PyObject 結構

變長物件：PyVarObject

【設計層】參考計數

工作原理

參考計數的增減時機

參考計數的優缺點

【實作層】觀察物件

使用 id() 觀察記憶體位址

小整數快取

字串駐留（String Interning）

使用 ctypes 觀察記憶體

觀察物件大小

【深入】PyTypeObject

型別物件的結構

在 Python 中觀察型別資訊

為什麼 is 比 == 快？

【實戰】效能影響

避免不必要的物件建立

使用物件池

思考題

實作練習

延伸閱讀

3.2 記憶體管理與垃圾回收

先備知識

本章目標

【原理層】記憶體模型

Stack vs Heap

Python 的記憶體分配器

【設計層】循環參考問題

參考計數的限制

分代垃圾回收

GC 觸發時機

【實作層】記憶體優化

使用 slots

為什麼 __slots__ 省記憶體？

slots 的限制

使用弱參考

使用 WeakValueDictionary 實作快取

【實作層】記憶體分析工具

使用 tracemalloc

使用 gc 模組除錯

檢測記憶體洩漏

【實戰】常見記憶體問題

問題 1：大量小物件

問題 2：循環參考

問題 3：全域變數累積

思考題

實作練習

延伸閱讀

3.3 Bytecode 與虛擬機

先備知識

本章目標

【原理層】Python 的執行流程

編譯與執行

.pyc 檔案與 pycache

程式碼物件（Code Object）

【設計層】Stack-based 虛擬機

工作原理

常見 Bytecode 指令

【實作層】使用 dis 模組

基本用法

分析控制流程

比較不同實現

【效能】從 Bytecode 理解效能

為什麼區域變數比全域變數快？

為什麼 list comprehension 比 for 迴圈快？

字串連接的效能

【深入】Python 3.11+ 的優化

Specializing Adaptive Interpreter

查看特化指令

內聯快取（Inline Caching）

【實戰】效能調校

使用 bytecode 分析熱點

避免不必要的屬性查找

為什麼 `slots` 省記憶體？