拆掉 GIL 这堵墙之后:Python 3.13 自由线程在 FastAPI 与 Django 里的真实取舍

引言

先讲一个我上周遇到的真实故障。

我们有个服务用 FastAPI 写,接口里要做两件"重活":一是调用 pycryptodome 做一批 RSA 签名,二是用 numpy 做一段特征向量的距离计算。单请求耗时 40ms,其中加密占 25ms、numpy 占 10ms、框架开销 5ms。压测到 8 并发时,QPS 死活上不去,CPU 却只跑到 130%(8 核机器)。运维看着监控问我:机器明明闲着,为什么扛不住?

答案大家都很熟:这些是 CPU 密集的纯 Python/C 扩展调用,在 GIL 之下同一时刻只有一个线程能执行字节码,8 个 worker 进程之外的并发线程全在排队等锁。于是我们加进程、加机器,用"多进程 + 负载均衡"这套老办法硬扛——机器成本翻了一倍,冷启动内存也翻了一倍。

Python 3.13 的 free-threaded 构建(PEP 703,俗称 no-GIL)第一次把这个前提动摇了:它允许线程真正并行执行字节码。但"拆掉 GIL"这件事,远没有宣传语那么浪漫。这篇文章我想回答三个具体问题:

  1. 3.13 的无 GIL 到底改了什么、没改什么?源码层面偏置锁(biased reference counting)是怎么兜住引用计数安全的?
  2. 在 FastAPI 和 Django 这两种典型 Web 框架里,自由线程到底能带来多少收益、又会引入什么坑?
  3. 什么时候该用、什么时候千万别用?

先给结论,后面慢慢论证:自由线程不是"多线程突然变快"的魔法,而是把"用进程换并行"的成本,换成了"用锁和内存换并行"的成本。它适合 CPU 密集但有细粒度并行的场景,不适合绝大多数 IO 密集的 Web 服务——后者早就该用 async 了。


核心概念:从"后厨只有一口锅"说起

生活类比:GIL 是后厨唯一的那口炒锅

把 CPython 解释器想象成一家餐厅后厨:

  • 线程 = 厨师
  • 字节码执行 = 炒菜
  • GIL = 后厨只有一口炒锅

不管你有几个厨师,同一时刻只有一个人能站在锅前炒菜。其他厨师可以切菜(等 IO)、可以看订单(等网络),但一旦要"下锅"(执行 Python 字节码),就得抢锅。这就是为什么多线程 IO 密集能提速(等 IO 时让别人炒),CPU 密集不能提速(大家都在抢锅)。

多进程 相当于开多家分店,每家一口锅。能真并行,但房租(内存)、备货(冷启动)、跨店协调(IPC 序列化)都是成本。

free-threaded 构建 相当于给后厨配了多口锅——但要解决一个新问题:如果两个厨师同时伸手去拿同一个调料罐(共享对象),怎么办?GIL 时代这个问题被"只有一口锅"天然屏蔽了,现在必须靠细粒度锁 + 引用计数改造来兜底。

技术定义

Python 3.13 提供两种构建:

构建 配置 GIL 说明
默认构建 默认 有 生产推荐,主流
free-threaded --disable-gil 编译,运行时 python3.13t 无(可选开启) 实验性,PEP 703

关键认知:"无 GIL"指的是解释器不再用一把全局锁串行化字节码执行,而不是"没有锁"。 对象访问、引用计数、容器操作依然有锁,只是粒度从"全解释器一把"变成了"对象级/结构级"。


源码级深度分析:GIL 拆掉之后,谁在兜底?

这一节是全文最硬的部分。我们要看三件事:GIL 到底守护了什么、偏置引用计数怎么工作、以及"暂停 GIL"这套机制为什么在 free-threaded 下依然存在。

1. GIL 守护的核心:引用计数 + 字节码原子性

看 CPython 3.12 的 Python/ceval_gil.c 里最经典的宏:

// Include/internal/pycore_ceval.h (3.12)
#define _Py_atomic_load_relaxed(ATOMIC_VAL) ...
// ceval_gil.c 中的 GIL 获取
void
_PyEval_RestoreThread(PyThreadState *tstate)
{
    // 抢 GIL,抢不到就进 COND_WAIT
    take_gil(tstate);
    ...
}

GIL 其实守护两样东西:

  1. 引用计数的原子性。Py_INCREF/Py_DECREF 在 3.12 里是裸的 ob_refcnt++,没有原子指令,靠 GIL 保证不同时改。
  2. 字节码间的内存可见性与操作原子性。list.append 在字节码层面是多步操作,GIL 保证不会中途被打断到数据不一致。

把 GIL 拿掉,这两条全部失效。CPython 团队的解法是 PEP 703 的偏置引用计数(biased reference counting)。

2. 偏置引用计数:把"全局锁"降到"对象本地锁"

核心洞察:绝大多数对象的引用计数修改,都来自创建它的那个线程。 只有跨线程共享的对象才需要同步。

所以 CPython 把引用计数拆成两部分(源码见 Include/object.h 与 Objects/object.c,3.13):

// 简化示意,3.13 free-threaded 下 PyObject 的引用计数布局
typedef struct _object {
    // ob_refcnt 被拆成 ob_ref_local + ob_ref_shared
    // local 部分只由"拥有该对象的线程"修改,无需原子操作
    uintptr_t ob_ref_local;      // 本线程本地计数
    _Py_atomic_uintptr_t ob_ref_shared;  // 共享计数,原子操作
    ...
} PyObject;

对应到宏,Py_INCREF 在 free-threaded 下大致是:

// 伪代码,体现逻辑
static inline void _Py_INCREF(PyObject *op) {
    PyThreadState *tstate = _PyThreadState_GET();
    if (op->ob_ref_local != 0 &&
        _Py_IsOwnedByCurrentThread(op, tstate)) {
        // 快路径:对象属于本线程,直接改本地计数,无原子操作
        op->ob_ref_local += 1;
    } else {
        // 慢路径:跨线程共享,走原子加
        _Py_atomic_add(&op->ob_ref_shared, 1);
    }
}

这个设计非常漂亮,也是一个绝佳的生活类比:每个厨师有自己的调料盒(local 计数),自己用自己盒里的,不用跟别人抢;只有当调料要端到别人灶台上(跨线程共享)时,才去公共台面(shared 原子计数)登记。 大部分时候走快路径,性能损失被压到很低。

当对象的 local 计数归零、且没有其他线程持有引用时,才需要"合并" local 和 shared,判断是否真该回收。合并操作叫 _Py_MergeZeroLocalRefcount,需要拿对象所属线程的状态锁——这是 free-threaded 下性能热点之一。

3. "停世界"(stop-the-world)依然存在

很多文章说"无 GIL 就没有停顿了",这是错的。free-threaded 构建里仍然有 暂停所有线程 的机制,典型场景:

  • 垃圾回收(尤其是循环 GC)
  • 某些类型对象的清理
  • sys.setswitchinterval 相关的调度

源码里 _PyEval_StopTheWorld / _PyEval_StartTheWorld(Python/ceval_gil.c)就是干这个的。区别在于:GIL 时代停世界是"常态"(每次切换都涉及锁竞争),free-threaded 时代停世界是"事件"(只在需要全局一致视图时发生)。

4. 一个必须知道的现实:C 扩展的兼容性

这是最大的坑,没有之一。free-threaded 构建要求 C 扩展显式声明自己支持无 GIL,否则导入时会被强制重新启用 GIL(或者直接不可用)。声明方式是模块定义里加 Py_MOD_GIL_NOT_USED:

// 一个支持 free-threaded 的 C 扩展模块定义
static struct PyModuleDef mymodule = {
    PyModuleDef_HEAD_INIT,
    .m_name = "mymodule",
    .m_size = -1,
    // 关键:声明本模块不依赖 GIL
    .m_slots = (PyModuleDef_Slot[]){
        {Py_mod_gil, Py_MOD_GIL_NOT_USED},
        {0, NULL}
    },
};

如果你的依赖链里有任何一个老扩展没声明,整个进程的 GIL 会被悄悄打开,你所有的"无 GIL"努力瞬间归零——而且不会报错,只会静默降级。这就是为什么 3.13 只能算实验特性。


实战代码:三个可运行的例子

理论讲完,上代码。三个例子分别覆盖:CPU 并行收益验证、FastAPI 中的正确姿势、以及一个"踩坑现场"。

运行环境:Python 3.13 free-threaded 构建(python3.13t)。默认构建下这些代码也能跑,只是 CPU 密集部分不会加速——正好用来对比。

示例 1:验证 CPU 密集任务是否真的并行

"""
并行度验证脚本。
在默认构建和 free-threaded 构建下分别运行,对比耗时。
"""
import threading
import time

def cpu_bound_work(n: int) -> int:
    """纯 Python 计算,模拟 CPU 密集负载。
    刻意用 Python 循环而非 numpy,确保执行的是字节码,
    这样 GIL 的影响才会真实暴露。"""
    total = 0
    for i in range(n):
        total += i * i
    return total

def run_sequential(n: int, workers: int) -> float:
    start = time.perf_counter()
    for _ in range(workers):
        cpu_bound_work(n)
    return time.perf_counter() - start

def run_threaded(n: int, workers: int) -> float:
    threads = [threading.Thread(target=cpu_bound_work, args=(n,))
               for _ in range(workers)]
    start = time.perf_counter()
    for t in threads:
        t.start()
    for t in threads:
        t.join()
    return time.perf_counter() - start

if __name__ == "__main__":
    N = 5_000_000
    WORKERS = 4

    seq = run_sequential(N, WORKERS)
    thr = run_threaded(N, WORKERS)

    print(f"顺序执行 {WORKERS} 次: {seq:.3f}s")
    print(f"多线程执行 {WORKERS} 次: {thr:.3f}s")
    print(f"加速比: {seq / thr:.2f}x")
    # 默认构建:加速比 ≈ 1.0(线程在抢 GIL)
    # free-threaded 构建:加速比 ≈ 3~4x(真并行,取决于核数)

这段代码的妙处在于:它不需要改任何业务逻辑,就能判定你手里的解释器到底是哪种构建。 加速比接近 1 说明 GIL 还在(或某个扩展把它打开了),接近核数说明真并行。我建议每个准备迁移的团队先跑这个基准。

示例 2:FastAPI 中正确使用自由线程

FastAPI 的 async def 端点跑在事件循环里,绝对不能在里面做 CPU 密集计算——会阻塞整个循环。传统做法是丢进 run_in_executor 的线程池,但在 GIL 下线程池对 CPU 密集无益。free-threaded 下,这个线程池终于能"物尽其用"了。

"""
FastAPI + free-threaded 的 CPU 密集端点示例。
核心:async 端点只做 IO 编排,CPU 重活交给线程池。
"""
from concurrent.futures import ThreadPoolExecutor
import hashlib
import asyncio
from fastapi import FastAPI
import numpy as np

app = FastAPI()

# 线程池大小建议 = CPU 核数(CPU 密集),不要按 IO 密集的惯例开很大
_executor = ThreadPoolExecutor(max_workers=4, thread_name_prefix="cpu")

def _heavy_compute(seed: int) -> dict:
    """CPU 密集任务:哈希 + 向量运算。
    在 free-threaded 构建下,多个线程可真正并行执行。"""
    # 1) 纯 Python 哈希链(字节码密集)
    h = hashlib.sha256()
    for i in range(200_000):
        h.update(f"{seed}-{i}".encode())
    digest = h.hexdigest()

    # 2) numpy 运算:注意!numpy 自身是否释放 GIL 取决于其构建,
    #    free-threaded 下需使用支持 Py_MOD_GIL_NOT_USED 的版本
    vec = np.random.default_rng(seed).random(1_000_000)
    norm = float(np.linalg.norm(vec))

    return {"digest": digest[:16], "norm": norm}

@app.get("/compute/{seed}")
async def compute(seed: int):
    # 关键:用 run_in_executor 把阻塞任务踢出事件循环
    loop = asyncio.get_running_loop()
    result = await loop.run_in_executor(_executor, _heavy_compute, seed)
    return result

这里有个极易踩的坑:很多人以为装了 free-threaded 解释器,run_in_executor 就自动快了。错。你要确认两件事:(1) 你的 hashlib、numpy 等扩展在 free-threaded 下没有被强制打开 GIL;(2) 线程池大小按 CPU 核数配,配太大只会增加上下文切换和内存竞争。用示例 1 的基准脚本先验证扩展兼容性,再上生产。

示例 3:踩坑现场——你以为的无 GIL,其实被扩展关掉了

"""
GIL 静默降级检测脚本。
用来排查"为什么我开了 free-threaded 还是不提速"。
"""
import sys
import sysconfig
import threading
import time

def check_build():
    print("=" * 50)
    print(f"Python 版本: {sys.version}")
    # 是否 free-threaded 构建
    gil_disabled = sysconfig.get_config_var("Py_GIL_DISABLED")
    print(f"Py_GIL_DISABLED 编译变量: {gil_disabled}")
    # 运行时 GIL 是否真的被启用(可能被扩展重新打开)
    if hasattr(sys, "_is_gil_enabled"):
        print(f"运行时 GIL 启用状态: {sys._is_gil_enabled()}")
    else:
        print("运行时 GIL 状态: 无法检测(非 free-threaded 构建)")
    print("=" * 50)

def _spin(n: int):
    x = 0
    for _ in range(n):
        x += 1
    return x

def benchmark(workers: int = 4, n: int = 3_000_000):
    # 用线程并行度间接反映 GIL 是否存在
    ts = [threading.Thread(target=_spin, args=(n,)) for _ in range(workers)]
    start = time.perf_counter()
    for t in ts: t.start()
    for t in ts: t.join()
    return time.perf_counter() - start

if __name__ == "__main__":
    check_build()

    # 先测"导入前"的并行度
    t_before = benchmark()

    # 导入一个可能不支持 free-threaded 的扩展
    try:
        import _pickle  # 仅作示例,实际替换为你怀疑的扩展
    except ImportError:
        pass

    t_after = benchmark()

    print(f"导入前耗时: {t_before:.3f}s")
    print(f"导入后耗时: {t_after:.3f}s")
    if sys._is_gil_enabled() if hasattr(sys, "_is_gil_enabled") else True:
        print("⚠️  GIL 处于启用状态:检查是哪个 C 扩展拖了后腿")
    else:
        print("✅ GIL 已禁用,真并行生效")

这个脚本的价值在于:sys._is_gil_enabled() 是你在 free-threaded 时代的"体温计"。任何一次 import 之后它变成 True,就说明某个扩展把你打回了 GIL 世界。上线前把它加进启动自检,能省掉无数深夜排障。


架构对比:进程池、异步、自由线程三选一

很多人问"有了无 GIL,是不是就不用多进程了?"不是。这是三种不同层次的并行模型,适用场景完全不同。先看一张图:

graph TD A[收到 CPU 密集请求] --> B{任务能否切成
细粒度并行?} B -->|能, 共享大量内存| C[自由线程 + 线程池] B -->|不能, 单任务极重| D[进程池 / 独立 worker] C --> E{依赖的 C 扩展
是否支持 no-GIL?} E -->|是| F[真并行, 内存共享, 推荐] E -->|否| G[静默降级为 GIL, 退回进程池] D --> H[进程隔离, 内存翻倍, 冷启动慢] A --> I{瓶颈是 IO?} I -->|是| J[async/await 单线程事件循环] J --> K[不要用线程池, 浪费]

三者对比如下:

维度 多进程 async/await 自由线程
并行粒度 进程级 协程级(非并行) 线程级
内存开销 高(每进程独立堆) 低 低(共享堆)
通信成本 高(序列化/IPC) 无(同进程) 无(共享内存)
适合负载 单任务重、隔离要求高 IO 密集 CPU 密集且可切分
成熟度(3.13) 极高 高 实验性
主要风险 内存、冷启动 阻塞调用会卡全循环 C 扩展兼容、数据竞争

我的判断:绝大多数 Web 后端(FastAPI/Django 的典型 CRUD + 少量计算)的瓶颈根本不在 CPU 并行,而在 IO 和数据库。这类服务应该优先把 async 用对、把阻塞调用踢出事件循环,而不是急着上自由线程。自由线程真正发光的是单体进程内需要共享大块内存做并行计算的场景——比如进程内缓存了 2GB 特征矩阵、要并发做多路检索,这时多进程的内存复制成本高得离谱,自由线程才是解。

顺带说 Django:Django 是同步框架为主(虽有 async 支持,但生态里大量 ORM 调用仍是同步的),它在 free-threaded 下的收益主要来自 WSGI 服务器(如 gunicorn 的 gthread worker)里的 CPU 密集视图。但同样的建议——先用 --workers 多进程把机器吃满,只有在内存吃紧、进程复制成本过高时,才考虑 free-threaded + 线程 worker 的组合。


最佳实践与避坑指南

这一节是血泪总结,按优先级排。

1. 先测再迁,用示例 1 的基准脚本给现有服务"体检"

不要凭感觉判断"我们服务是 CPU 密集"。用 profiler(py-spy、cProfile)量出真实热点。很多团队以为自己在做计算,其实 80% 时间在等数据库。

2. 把 sys._is_gil_enabled() 加进启动自检

示例 3 已经给出检测逻辑。在 free-threaded 构建上,启动时打印 GIL 状态,并在关键 import 后复查。一旦发现被扩展降级,要么换扩展、要么放弃这个构建——不要心存侥幸。

3. 线程池大小按 CPU 核数配,别按 IO 密集的老习惯

IO 密集线程池开几十上百没问题(线程大多在等);CPU 密集线程池开超过核数只会增加锁竞争和 GIL 争用(默认构建下更糟)。max_workers = os.cpu_count() 是起点。

4. 警惕数据竞争——GIL 曾经帮你兜住的 bug 会集中爆发

GIL 时代很多"看起来线程安全"的代码,其实靠的是字节码原子性。比如 counter += 1 在 GIL 下大概率安全(虽然严格说也不是原子的),但 free-threaded 下 LOAD/ADD/STORE 三步之间可能被打断。所有共享可变状态必须用 threading.Lock 或换成 queue.Queue、multiprocessing 的共享结构。建议上 pytest-xdist + 压力测试,把竞争条件逼出来。

5. 检查依赖树的 no-GIL 支持度

pip 装包时注意是否有 free-threaded 轮子(cp313t 标签)。numpy、pandas 等大扩展的支持进度是关键卡点。没有 cp313t 轮子的包需要源码编译,且要确认它声明了 Py_MOD_GIL_NOT_USED。

6. 别在生产用实验特性做核心链路

3.13 的 free-threaded 是"可用的实验",不是"成熟的生产方案"。我的建议:灰度用、旁路用、压测用。等 3.14/3.15 生态跟上、ABI 稳定后再考虑核心链路。

7. FastAPI 里坚持"async 编排 + 线程池计算"的分层

再强调一次:async def 端点里绝不写 CPU 密集代码,也绝不写阻塞 IO。用 run_in_executor 或 asyncio.to_thread 把重活踢出去。这个原则在有没有 GIL 的时代都成立。


总结

回到开头那个故障。如果今天让我重做那个服务,我会这么排优先级:先确认加密和 numpy 是否 IO 等待为主(不是),再确认能不能把大任务切小并发(能),最后才考虑 free-threaded。 而即便用了,我也会保留多进程作为兜底——因为 free-threaded 的收益高度依赖"扩展是否支持 + 数据是否可安全共享"这两个前提。

把全文压缩成三句话:

  1. 自由线程拆的是"全局锁",不是"所有锁"。偏置引用计数把大部分引用计数操作降到线程本地,代价是跨线程共享对象的原子操作和停世界 GC。
  2. 它的甜点是"进程内共享大内存 + 细粒度 CPU 并行"。IO 密集继续用 async,单任务重继续用多进程,别为了新特性而新特性。
  3. 3.13 是实验,最大风险是 C 扩展静默降级。上线前把 sys._is_gil_enabled() 当体温计,用基准脚本当体检,用锁当安全带。

延伸思考:GIL 被拆掉之后,Python 的内存模型会成为新的学习重点——就像 Java 程序员必须懂 JMM 一样,未来的 Python 工程师可能要懂"Python 的 happens-before 是什么"。这扇门刚打开,路还长。真正值得现在投入的,不是急着迁移,而是把 async 用对、把共享状态管好——这两件事,无论有没有 GIL,都是硬功夫。