📑 本页目录(点开跳转)
04 · GIL:为什么多线程救不了你
实验记录怎么读
本页原有耗时、内存、报错和环境值保留为原文记录;本轮内容审校未逐项复跑这些实验。版本、硬件、数据和测量方法都会影响结果,示例中的倍数也不是保证。需要复现时先核对依赖版本,再在同一输入下比较。
⏱ 94 分钟 | ⭐ 在启用 GIL 的 CPython 中,选择线程或进程须结合等待/计算、具体操作的 GIL 行为与端到端成本;原实验中 np.sort 开线程约快 3 倍,json.loads 几乎未加速,这些是该次负载记录。
🎯 一句话
本章首先讨论启用 GIL 的 CPython 解释器:同一解释器中通常只有一个线程执行 Python 字节码。阻塞 I/O 和某些明确释放 GIL 的原生计算可以并发;“用 C 实现”本身不保证释放 GIL。free-threaded 构建需另查实际运行状态。
🧩 一、GIL 是什么:同一解释器内的锁
GIL 全称 Global Interpreter Lock,全局解释器锁。它的规则用一句话讲完:
⭐ 在本章启用 GIL 的 CPython 中,同一解释器里,同一时刻只有一个线程能执行 Python 字节码。 这里的 100 个线程共享同一解释器;操作系统即使把它们分配到不同的核上,它们仍要排队抢同一把 GIL。
先看你的解释器现在是什么形状:
# 你的解释器现在是什么形状:启动方式 + GIL 在不在
import multiprocessing as mp, sys
if __name__ == "__main__":
print("平台 :", sys.platform)
print("默认启动方式 :", mp.get_start_method())
print("本平台可选 :", mp.get_all_start_methods())
print("GIL 还在吗 :", getattr(sys, "_is_gil_enabled", lambda: "该版本没有这个函数")())
print("线程切换间隔 :", sys.getswitchinterval(), "秒")
本机(8 核 Windows 11 / CPython 3.13)输出:
对照
平台 : win32
默认启动方式 : spawn
本平台可选 : ['spawn']
GIL 还在吗 : True
线程切换间隔 : 0.005 秒
⭐ 最后那行 0.005 秒是解释器线程切换的目标(理想)间隔,不是固定交锁周期:长时间运行的内部函数或方法可能使实际间隔更长。它既不保证每 5 毫秒交还 GIL,也不保证此时操作系统完成一次线程切换;接下来哪个可运行线程获得调度,由操作系统决定,解释器没有自己的线程调度器。在本章同一解释器内,持有 GIL 执行 Python 字节码的线程仍是轮流跑,不是同时跑。
为什么会有这么一把锁:CPython 用引用计数管内存,每个对象身上挂着一个「有几个名字指着我」的计数器(这就是 01 章里那些「标签」的实现)。这个计数器几乎每执行一条字节码都会被加减一次。如果两个线程同时改同一个计数器,就会出现「都以为自己是最后一个」于是重复释放,或者「都以为对方还在用」于是永远不释放。
⭐ 给每个对象配一把锁在技术上可行,但代价是给每一次加减都加锁——单线程程序会因此显著变慢。GIL 是「一把大锁换掉几亿把小锁」的工程折衷:单线程最快,多线程受罚。
🔎 可选深入:交还 GIL,不等于操作系统完成一次切换
⭐ 把层次分开:进程提供地址空间与资源,线程是其中的一条执行流;同一进程的线程共享地址空间和许多资源,各有寄存器上下文、栈和线程局部状态。这里说普通 CPython 的原生线程:Windows 以线程参与调度,现代 Linux 的内核调度实体也包含这些原生线程;协程或 GIL 不是 OS 的调度单位。
| 一次 OS 切换要处理 | 应用里能怎样理解 |
|---|---|
| 保存/恢复执行现场 | 保存当前线程所需寄存器状态、栈与续跑位置,再恢复下一线程;具体寄存器和保存路径依架构/内核 |
| 更新调度状态 | 当前线程可能等待资源或时间片结束;调度器选择可运行线程,并更新相关队列/状态 |
| 处理地址空间上下文 | 同进程线程通常共享地址空间;换到不同地址空间还可能换页表上下文,并影响 TLB/缓存的复用 |
这解释了“进程切换通常更贵”的一个来源,但不是永远更慢的定理;硬件地址空间标签、缓存是否命中、跨核迁移及内核路径都会影响代价。不能说每次换进程都清空全部 TLB,也不能用后文的 pickle/进程启动耗时替代一次上下文切换耗时。
本节原来的 CPython 切换间隔只帮助理解解释器竞争,不等于 OS 调度时间片。这里只补读 Python 并发例所需的边界,不展开 PCB、CFS 或调度算法清单。
依据:Windows 进程/线程上下文、Linux pthreads、Linux v6.6 context_switch 源码及x86 TLB 文档。这些是机制依据,不是本轮 Linux/Windows 调度实测。
🧩 二、纯 Python 的 CPU 活:线程一点忙都帮不上
先把最常见的期待打掉。8 核机器,4 份一模一样的计算活:
# 纯 Python 的 CPU 活:串行 / 4 线程 / 4 进程
import math, time
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
def burn(n=3_000_000):
s = 0.0
for i in range(n):
s += math.sqrt(i)
return s
if __name__ == "__main__": # ⭐ Windows 上少这一行,多进程直接炸,见第五节
t = time.perf_counter()
[burn() for _ in range(4)]
print("串行 %.2f s" % (time.perf_counter() - t))
t = time.perf_counter()
with ThreadPoolExecutor(4) as ex:
list(ex.map(burn, [3_000_000] * 4))
print("4 线程 %.2f s" % (time.perf_counter() - t))
t = time.perf_counter()
with ProcessPoolExecutor(4) as ex:
list(ex.map(burn, [3_000_000] * 4))
print("4 进程 %.2f s" % (time.perf_counter() - t))
要点
串行 0.56 s
4 线程 0.73 s
4 进程 0.38 s
⭐ 看中间那一行:开了 4 个线程,比串行还慢。慢的那部分不是错觉,是抢锁和切换的开销——活一点没少干,还多干了「排队」这件事。
⚠️ 线程那一档在不同机器、不同轮次之间会在「和串行持平」到「比串行慢三成」之间摆动(我这台机器上三轮分别是 0.57 / 0.60 / 0.75 s,对应的串行是 0.56 / 0.62 / 0.86 s)。要看的不是绝对数,是它从来不会接近 4 倍。
⚠️ 而进程那一档也只快了 1.5 倍,不是 4 倍——因为起进程本身要钱:
# 起进程本身要多少钱
import time
from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
def noop(x):
return x
if __name__ == "__main__":
t = time.perf_counter()
with ThreadPoolExecutor(4) as ex:
list(ex.map(noop, range(4)))
print("起 4 个线程 + 跑 4 个空任务 %.3f s" % (time.perf_counter() - t))
t = time.perf_counter()
with ProcessPoolExecutor(4) as ex:
list(ex.map(noop, range(4)))
print("起 4 个进程 + 跑 4 个空任务 %.3f s" % (time.perf_counter() - t))
对照
起 4 个线程 + 跑 4 个空任务 0.002 s
起 4 个进程 + 跑 4 个空任务 0.387 s
⭐ 0.002 s 对 0.387 s,差了近 200 倍。 这 0.39 秒是净开销,从并行省下的时间里扣。任务总时长如果不到一秒,多进程大概率是亏的。
⭐ 三、真正的分界:这个操作放不放 GIL
上一节容易让人得出「CPU 密集就用进程」的结论。那个结论太粗,而且恰好在最常见的两个场景上给出相反的建议。
关键在于:GIL 可以在不访问 Python 对象或 Python C API 的原生工作区段主动释放,再于需要时取得。扩展可使用 Py_BEGIN_ALLOW_THREADS 等机制实现这种分区;这给其他线程执行的机会,是否在不同 CPU 核上并行仍取决于可运行工作、调度和资源,不能只凭放锁或加速倍数断言核心归属。
同样是「CPU 密集」,两个库的选择不一样:
# 同样是「CPU 密集」,线程池管不管用取决于这个操作放不放 GIL
import json, time
import numpy as np
from concurrent.futures import ThreadPoolExecutor
arrays = [np.random.rand(8_000_000) for _ in range(4)]
blob = json.dumps([{"id": i, "v": [i, i + 1, i + 2]} for i in range(300_000)])
blobs = [blob] * 4
print("JSON 大小 %.1f MB" % (len(blob) / 1e6))
def timed(fn):
t = time.perf_counter(); fn(); return time.perf_counter() - t
def np_serial(): [np.sort(a) for a in arrays]
def np_thread():
with ThreadPoolExecutor(4) as ex: list(ex.map(np.sort, arrays))
def js_serial(): [json.loads(b) for b in blobs]
def js_thread():
with ThreadPoolExecutor(4) as ex: list(ex.map(json.loads, blobs))
for name, f in [("np.sort 串行", np_serial), ("np.sort 4线程", np_thread),
("json 串行", js_serial), ("json 4线程", js_thread)]:
print("%s %.2f s" % (name, min(timed(f) for _ in range(3)))) # ⭐ 取最小值,理由见 05 章
JSON 大小 13.7 MB
| 任务 | 串行 | 4 线程 |
|---|---|---|
| np.sort | 0.80 s | 0.25 s |
| json | 1.51 s | 1.45 s |
⭐ 这四行就是本章的正题:
| 操作 | 串行 | 4 线程 | 倍数 | 为什么 |
|---|---|---|---|---|
np.sort 排 800 万个 float |
0.80 s | 0.25 s | ⭐ 3.2× | 原 float 排序负载在线程池中获得加速;底层计算区的 GIL 行为须按所用版本核实现,计时不证明整个调用始终放锁,也未测量线程与 CPU 核的对应。 |
json.loads 解析 13.7 MB |
1.51 s | 1.45 s | 1.04× | 本章启用 GIL 的 CPython 中,普通 json.loads 解析受锁约束;访问和构造 Python 对象须满足对应锁要求,但不能把“全程在构造对象”当作通用等价判据,1.04× 也不单独证明锁状态。 |
⭐ 这里限定启用 GIL 的 CPython:要核对具体操作、数据类型与实现是否释放 GIL,不能只背库名。例如 NumPy 的 object dtype 操作不释放 GIL;上面的 float 排序实验不能推广到所有数组操作。释放 GIL 也不保证加速,还要看数据共享、内存带宽与调度开销。
| 可能释放 GIL 的候选(须核对具体操作) | 启用 GIL 时受锁约束的例子 |
|---|---|
| numpy / scipy 中已确认释放 GIL 的具体操作与数据类型;不能泛化到 object dtype | 纯 Python 的循环、字符串拼接、字典操作 |
| PyTorch 中已确认释放 GIL 的具体算子,按版本与实现核对 | json.loads / json.dumps |
压缩解压(zlib / gzip / bz2) |
re 正则匹配(不放) |
hashlib 摘要(数据够大时) |
绝大多数纯 Python 写的第三方库 |
具体实现会在阻塞等待区段释放 GIL 的 I/O,例如本章 time.sleep;文件读写和 socket 仍须区分阻塞等待、缓冲命中及调用前后的 Python 处理。 |
pickle 序列化本身 |
⚠️ 具体操作的 GIL 行为应另核版本文档或源码,不能由计时倍数推断。下面保留原记录中串行与四线程的耗时对照;它们描述本次收益,不是“放锁/不放锁”的测量方法。
| 操作 | 串行 | 4 线程 | 倍数 | 结论 |
|---|---|---|---|---|
re.findall 在 320 万字符上找模式 |
0.223 s | 0.217 s | 1.03 | ❌ 不放锁 |
zlib.compress 压 10 MB |
0.240 s | 0.086 s | 2.78 | ✅ 放锁 |
hashlib.sha256 摘要 50 MB |
0.174 s | 0.110 s | 1.58 | ✅ 本例 50 MB 输入满足该实现的释放条件;hashlib 是否释放还取决于单次输入大小(官方接口说明超过 2047 字节),不能把小输入一概解释为仅有调用开销。 |
⭐ 不确定的时候别猜,量一遍。 上面那 12 行就是模板:同一个函数,串行一次、四线程一次,看倍数。倍数只说明这次实测的并发收益,不能证明放不放 GIL;接近 1 也可能受带宽、开销或共享争用限制。锁状态仍须按具体操作、类型与实现核对。怎么把这种测量做对(预热、取最小值、别被缓存骗),是 05 章整章的内容。
⭐ 站内有一处正好卡在这条分界线上。AI全栈 03 · 后端骨架 讲 async 服务时说:真 CPU 活——解析 50 MB JSON、本地算 embedding——async 救不了,只能扔线程池或独立进程。 那句话把这类活指向了两个选项,而没说什么时候该选哪个。⭐ 这一章补的就是那个判据:在启用 GIL 的 CPython 中,本地 embedding 若具体操作与类型已确认释放 GIL,可先评估线程池;普通 JSON 解析可评估进程池,但也要计入进程启动和数据搬运成本。仅凭 numpy / torch 的库名不能断言线程池管用。
🚦 四、三种并发怎么选
在启用 GIL 的 CPython 中,把「具体操作是否释放 GIL」和「在等还是在算」交叉,可得到选择起点;数据共享、带宽与开销还会改变结果,答案不是唯一的:
| 你的活 | 选什么 | 为什么 |
|---|---|---|
在等网络 / 磁盘 / 数据库,而且库是 async 的 |
⭐ async | 异步 I/O 可在事件循环中交错推进可挂起的等待;这不是按 GIL 释放或固定连接数保证容量,CPU/阻塞回调仍可能挡住循环。 |
在等,但手上的库是同步的(requests、老的数据库驱动) |
⭐ 线程池 | 若该同步库在阻塞等待时释放 GIL,可先评估线程池;仍需核具体 API、并发安全与资源上限,不能只凭“同步 I/O”保证效果。 |
| 在算,具体操作与数据类型已确认释放 GIL | ⭐ 线程池 | 可先评估线程池,避免进程启动与序列化成本;仍须防止共享写入争用,核对带宽和线程开销,不承诺加速 |
| 在算,纯 Python 代码(解析、循环、正则) | ⭐ 进程池 | 本章普通单解释器示例用进程池,让各进程拥有独立的解释器与 GIL |
| 在算,纯 Python,但数据非常大 | ⚠️ 先算账,见第六节 | 搬数据的钱可能超过并行省下的钱 |
「在等」那一档的效果是最好看的——因为等待期间 GIL 是放开的,8 个任务能挤在一起等:
# 等待类的活:线程和 async 都能赢,因为等待的时候 GIL 是放开的
import asyncio, time
from concurrent.futures import ThreadPoolExecutor
def wait_io(_): # 假装是一次网络请求
time.sleep(0.25)
async def wait_io_async(_):
await asyncio.sleep(0.25)
async def gather_all():
await asyncio.gather(*(wait_io_async(i) for i in range(8)))
if __name__ == "__main__":
t = time.perf_counter(); [wait_io(i) for i in range(8)]
print("串行 %.2f s" % (time.perf_counter() - t))
t = time.perf_counter()
with ThreadPoolExecutor(8) as ex:
list(ex.map(wait_io, range(8)))
print("8 线程 %.2f s" % (time.perf_counter() - t))
t = time.perf_counter(); asyncio.run(gather_all())
print("async %.2f s" % (time.perf_counter() - t))
对照
串行 2.00 s
8 线程 0.25 s
async 0.27 s
⭐ 原等待负载记录为 2.00 → 0.25,正好 8 倍,线程和 async 在这组结果中接近;不能由此设定“几千连接”才有差别的固定分界。原文所述线程几百 KB 到几 MB 的栈、协程几 KB 是实现相关的量级示意,容量与收益还取决于任务、平台和调度,应在目标负载评估。
⛔ async 的语法、事件循环怎么转、为什么不能在协程里做阻塞调用,那些归 AI全栈 03 · 后端骨架。本章只负责「三种里该选哪种」。
🧩 五、进程模型:fork 和 spawn 是两件不同的事
先运行 multiprocessing.get_start_method() 并记录 Python 版本,不要只凭操作系统猜:CPython 3.13 的 Linux 等非 macOS POSIX 平台通常默认 fork;3.14 起,在支持 forkserver 的非 macOS POSIX 平台改为默认 forkserver,fork 不再是任何平台的默认。Windows 默认 spawn;macOS 在这里对照的 3.13/3.14 中默认 spawn。程序也可显式选择可用的上下文。下表只比较机制,不代替本机检查。参见 3.13 文档与3.14 文档。
选了进程之后,第二类坑就来了:子进程是怎么诞生的。这里对照 fork / spawn 两种造法,行为差得很远。另有 forkserver:先启动服务进程,由它接受请求并 fork 子进程;它不是直接复制当前应用进程,不能套用下表 fork 的全部父进程状态直觉。
| fork(如 CPython 3.13 的 Linux 默认;3.14 需显式选择) | spawn(Windows 默认;macOS 3.13/3.14 默认) | |
|---|---|---|
| 怎么造 | 把当前进程整个复制一份 | 从零启动一个新的 Python 解释器 |
| 子进程能看见什么 | 父进程 fork 那一刻的全部内存(写时复制) | ⭐ 什么都看不见,只有被 pickle 传过去的东西 |
| 启动开销 | 小 | 大(要重新 import 一遍所有模块) |
| 顶层代码 | 不会重跑 | ⭐ 会重跑一遍 |
| 线程 / 锁 | ⚠️ 只复制调用 fork 的那个线程,别的线程持有的锁会永远锁着 | 干净,没这个问题 |
⭐ spawn 会把你的主模块重新 import 一遍,这是 Windows 上所有多进程怪事的根源:
# spawn 会把这个模块【重新 import 一遍】:守卫外面的代码,每个子进程都会再跑一次
import os, time
from concurrent.futures import ProcessPoolExecutor
print("[模块顶层] pid=%d 我被执行了" % os.getpid())
STATE = {"loaded_at": time.time()} # 守卫【外面】:每个子进程都会重新造一份
def who(_):
return "pid=%d | STATE 里有 %d 个键 | EXTRA=%r" % (
os.getpid(), len(STATE), STATE.get("EXTRA"))
if __name__ == "__main__":
STATE["EXTRA"] = "主进程加上去的" # 守卫【里面】:子进程看不见
print("[主进程] pid=%d" % os.getpid())
with ProcessPoolExecutor(2) as ex:
for line in ex.map(who, range(2)):
print("[子进程]", line)
要点
[模块顶层] pid=19208 我被执行了
[模块顶层] pid=51172 我被执行了
[模块顶层] pid=35412 我被执行了
[主进程] pid=35412
[子进程] pid=19208 | STATE 里有 1 个键 | EXTRA=None
[子进程] pid=19208 | STATE 里有 1 个键 | EXTRA=None
(pid 数值和这几行的先后顺序每次都不同,几个进程的 stdout 是抢着刷的。)
⭐ 两条结论都在这段输出里:
[模块顶层]打了三次——两个子进程各把这个文件重新执行了一遍。所以顶层写的任何耗时代码(加载模型、连数据库、读大 CSV)都会被乘以进程数。- 子进程的
EXTRA是None。守卫里面改的那次修改,子进程完全不知道。进程之间不共享对象——这是 01 章全部「共享」直觉失效的地方:那一章说「赋值只是贴标签,两个名字指同一个对象」,跨进程之后连对象都是两个。
⚠️ if __name__ == "__main__" 不是仪式,是必需
如果没有那道守卫,子进程重新 import 主模块时会再次执行创建进程池的那一行,于是无限递归。CPython 检测到了这件事,报错如下(这是真实输出):
对照
RuntimeError:
An attempt has been made to start a new process before the
current process has finished its bootstrapping phase.
This probably means that you are not using fork to start your
child processes and you have forgotten to use the proper idiom
in the main module:
if __name__ == '__main__':
freeze_support()
·
⚠️ 报错还没完,主进程那边收到的是另一条完全不指向根因的消息:
concurrent.futures.process.BrokenProcessPool: A process in the process pool was
terminated abruptly while the future was running or pending.
💀 这就是为什么它难查:你在终端里看到的第一屏是 BrokenProcessPool,字面意思是「池子里有个进程突然死了」,读起来像资源不足或者环境问题;真正的 RuntimeError 被埋在一大堆 multiprocessing/spawn.py 的栈帧中间。而在 Jupyter / IDE 里,子进程的 stderr 常常根本不显示,你只会看到那句 BrokenProcessPool,然后开始怀疑人生。
📋 规矩:任何会用到多进程的脚本,一律把可执行代码放进 if __name__ == "__main__":。 顶层只留 import、常量和函数/类定义。这条在 Linux 上也照做——你写的脚本迟早会有人在 Windows 或 macOS 上跑。
🔎 可选深入:worker 结束了,资源也收完了吗?
沿着本节的 worker 看一个简化生命周期:创建 → 就绪 → 运行 → 等待 IO/锁 → 再就绪 → 结束。运行被抢占可回到就绪,等待的条件满足才回到就绪;这是解释模型,不是把所有 OS 状态字母硬配成同一张表。
| 问题 | 在本页程序里的边界 |
|---|---|
| 线程“崩溃” | Python Thread.run 的普通未捕获异常通常交给 threading.excepthook,使该线程结束;join 不自动把它重新抛到调用线程。原生致命错误/进程终止则可能结束整个进程,不能把两类故障混说 |
| 最多能开多少线程 | 没有跨平台固定数:栈/地址空间、内存与系统限额都约束创建。Linux 还可能受用户线程数资源限额、threads-max、pid_max 限制;不要靠无限创建去测生产上限 |
| Linux 中的僵尸 | 子进程已终止,但等待者尚未收取退出信息;保留少量记录供 wait/waitpid 回收,并非仍在运行的 Python worker |
| Linux 中的孤儿 | 父进程先退出;子进程由相应 init/subreaper 接管,可能还在运行。孤儿与僵尸描述不同关系,不能互当同义词 |
Linux 上可先用 ps -eo pid,ppid,stat,comm 观察 PID/父 PID/状态;STAT 首字母 Z 指向僵尸,再查父进程为何未回收。它已经结束,不能靠“再杀一次这个僵尸”让父进程补做 wait。R、S、D 等是具体 Linux 状态,别直接照搬成 Windows 的进程状态名。
在 Python 层保留 worker 句柄,按任务协议接收结果并调用适当的 join/进程池收尾;线程句柄等待、子进程回收和业务结果消费是不同动作。这里不运行僵尸/致命故障负例,也不承诺强制终止后未完成的数据会自动一致。
依据:Python 线程异常、pthread_create 资源限额、wait 的回收语义、Linux 状态字段。命令仅说明诊断入口,本轮未在 Linux 上执行。
⚠️ 六、pickle 的账:搬数据的钱可能比省下的还多
跨进程传参数和收结果,走的是 pickle:对象序列化成字节 → 通过管道传给子进程 → 子进程再反序列化成对象。这一来一回的钱经常被忽略。
# 进程间传参要 pickle:大对象搬过去的钱,可能比并行省下的还多
import pickle, time
import numpy as np
from concurrent.futures import ProcessPoolExecutor
def cheap(a): # 活很轻:只求个和
return float(a.sum())
if __name__ == "__main__":
arrays = [np.random.rand(8_000_000) for _ in range(4)] # 每份 64 MB
blob = pickle.dumps(arrays[0])
t = time.perf_counter(); pickle.dumps(arrays[0]); pk = time.perf_counter() - t
print("单份大小 %.0f MB | pickle 一次 %.3f s" % (len(blob) / 1e6, pk))
t = time.perf_counter(); [cheap(a) for a in arrays]
print("串行 %.3f s" % (time.perf_counter() - t))
t = time.perf_counter()
with ProcessPoolExecutor(4) as ex:
list(ex.map(cheap, arrays))
print("4 进程 %.3f s" % (time.perf_counter() - t))
对照
单份大小 64 MB | pickle 一次 0.055 s
串行 0.036 s
4 进程 0.870 s
💀 4 个进程比串行慢了 24 倍。 256 MB 的数据被序列化、塞进管道、再反序列化,而真正的计算只花了 36 毫秒。
⭐ 一条需要端到端测量的经验判断:
“计算时间达到 pickle 时间的 10 倍”只能作为经验启发,不是官方阈值,也不是多进程必然划算的条件。本轮没有复跑上面的原基准;其数字只描述原环境。应在同一任务与输入下比较串行和进程池的端到端耗时,计入启动/导入、双向序列化、传输、返回结果、任务粒度与池复用;fork、spawn、forkserver 以及 Python 版本会改变这笔账。上例 pickle 与计算的局部计时只提示搬运可能压过收益,不能单靠一个比率决定。
⚠️ 还有三个连带的坑:
| 坑 | 长什么样 |
|---|---|
| 不是所有东西都能 pickle | lambda、局部函数、打开的文件句柄、数据库连接、threading.Lock 都不行,报 PicklingError 或 TypeError: cannot pickle ... |
| 返回值也要 pickle | 子进程返回一个 2 GB 的 DataFrame,回程的开销和去程一样贵 |
| 内存被乘以进程数 | 4 个子进程各持一份 64 MB 的副本,峰值是 5 份而不是 1 份(怎么量峰值内存见 05 章) |
📋 避开办法:别传数据,传「去哪拿数据」。把 4 个进程各自要读的文件路径 / 行号区间 / 分片编号传过去,让它自己读。大数组还可以放进 multiprocessing.shared_memory 共享一块内存,只传名字。
🔎 可选深入:不搬大数组,仍要传控制消息
后文建议“传路径或共享内存名字”,并不表示进程间天然共享任意 Python 对象。先看载荷与控制各走哪条路:
| 方式 | 适合传什么 | 必须另管什么 |
|---|---|---|
| 管道/队列 | 字节流或序列化的消息;Python multiprocessing.Queue 常用于传小任务和结果 | 边界/协议、背压、退出与异常;不要把大对象反复塞回去又说没有拷贝 |
| 共享内存 | 让不同进程访问同一块字节,减少大载荷反复序列化/传输 | 数据布局、同步和生命周期;首次填充、转换视图仍可能拷贝,不是整个任务自动零拷贝 |
| socket | 同机或跨机的消息/流 | 连接、序列化、失败/重试协议;跨机不能直接用本机内存名字 |
| OS signal | 通知某类异步事件 | 不是通用对象消息队列;Python 的处理器在主解释器主线程执行,不能代替线程间消息传递 |
SharedMemory 用完要关闭各自句柄,并约定谁负责释放;POSIX 风格下由指定一方按协议 unlink,Windows 则在全部句柄关闭后删除,unlink 不起同样作用。Python 3.13 的 track/resource-tracker 行为还受进程启动关系影响,独立启动的程序应按官方文档确定谁记账,不能各自抢着清理仍有人在用的块。
信号量不是 signal:它以计数表达可用许可,acquire/release 协调多少任务能进入;OS signal 表达异步通知。共享数据需要的锁、事件或队列不会因为“发了个 signal”就自动安全。
依据:Python 3.13 共享内存、进程消息传递、signal 与线程。这里只比较与现有进程池直接相连的接口,不演示跨机部署。
💀 七、站内的两处,全是这一章的账
① DataLoader(num_workers=4) 在 Windows 上一跑就炸。
PyTorch 的 DataLoader 在 num_workers > 0 时就是一个进程池。所以第五节和第六节的账它一分不少:
| 现象 | 根因 | 怎么修 |
|---|---|---|
一开始训练就 BrokenPipeError / RuntimeError: ... bootstrapping phase |
训练脚本没有 if __name__ == "__main__" 守卫 |
把训练代码整段放进守卫里 |
Notebook 里设 num_workers>0 就卡死不动 |
spawn 要重新 import 主模块,而 Notebook 没有可 import 的「主模块文件」 | 把 Dataset 类和训练循环挪进 .py 文件再 import;或者在 Notebook 里就用 num_workers=0 |
| 数据集对象很大,worker 一起来内存就爆 | 每个 worker 拿到的是数据集对象的一份副本(第五节:进程之间不共享对象) | Dataset 里只存路径和索引,__getitem__ 里才真正读数据 |
| 每个 epoch 开头卡好几秒 | 每个 epoch 重建 worker,每次都付一遍 spawn 的钱(本机 4 进程 ≈ 0.39 s,import torch 之后更贵) | persistent_workers=True |
⛔ num_workers / prefetch_factor / pin_memory 具体该调到多少,归 AI基础设施 22 · 数据管线与存储。本章只负责解释为什么会炸。
② n_jobs=-1 为什么有时候反而更慢。
sklearn 的 n_jobs 走的是 joblib 的进程池,账和第六节一模一样。⚠️ 交叉验证时每个进程都要拿到一份训练数据的副本——5 折 × 一份 2 GB 的矩阵,峰值就是 10 GB。小数据集上 n_jobs=-1 常常比 n_jobs=1 还慢,因为搬数据的钱超过了并行省下的。
🧯 八、GIL 不等于线程安全
最后一个反直觉的地方:GIL 保护的是解释器自己的内部状态,不是你的代码。
「同一时刻只有一个线程在跑字节码」不等于「你的一行 Python 是一个整体」。total = plus_one(total) 分为读 → 调用 → 写回。另一个线程可能在读取和写回之间插入自己的操作。下面保留原来的调度演示。
# GIL 不等于线程安全:读—改—写中间只要有一次函数调用,就有换线程的机会
import sys, threading
sys.setswitchinterval(1e-6) # 默认 0.005 秒,这里调到百万分之一秒,把概率放大
def plus_one(x):
return x + 1 # ⭐ 一次函数调用 = 一个可以被换下去的点
total = 0
def bump(n=50_000):
global total
for _ in range(n):
total = plus_one(total) # 读 total → 调用 → 写回,三步不是一个整体
ts = [threading.Thread(target=bump) for _ in range(8)]
[t.start() for t in ts]; [t.join() for t in ts]
print("应该是 400000,实际是", total, " 丢了", 400_000 - total)
要点
应该是 400000,实际是 123085 丢了 276915
原环境的这次结果少了 276915 次更新。三次记录分别是 123085、116319、115419。这些是历史调度下的输出,不能作为通过标准。
sys.setswitchinterval(1e-6) 用于提高撞到该交错的机会。原 CPython 3.13 记录中,默认间隔下三次都没丢更新。几次正常结果只说明那几次调度没有触发问题。下面改用同步点复现同一类缺陷。
还剩一张票,两笔预约都能成功吗?
系统只剩一张票。两个线程接到预约请求,都要先查余量,有票才扣掉一张并确认。无论谁先执行,只要请求都结束,余量加成功数应该等于 1。这条关系就是本例的业务不变量。
回想 01 章的共享对象。这里两个线程访问的是同一个可修改的字典 stock。各自的 remaining 则是读出来的整数。一个线程改了共享字典,另一线程此前读到的整数仍可能是 1。
用屏障(barrier)让两个线程到齐再走,就能固定这次交错。ready 保证两个线程都参与,both_checked 只在无锁对照里使用,保证两次检查都先于任何一次扣减。下面是可直接运行的完整小例。
from concurrent.futures import ThreadPoolExecutor
from threading import Barrier, Lock
def simulate(use_lock):
stock = {"remaining": 1}
lock = Lock()
ready = Barrier(2, timeout=5)
both_checked = Barrier(2, timeout=5)
def reserve(force_interleaving=False):
remaining = stock["remaining"]
if remaining == 0:
return False
if force_interleaving:
both_checked.wait()
stock["remaining"] = remaining - 1
return True
def worker():
ready.wait()
if use_lock:
with lock:
return reserve()
return reserve(force_interleaving=True)
with ThreadPoolExecutor(max_workers=2) as pool:
requests = [pool.submit(worker) for _ in range(2)]
confirmed = sum(request.result() for request in requests)
return stock["remaining"], confirmed
print("无锁(余量,成功数)", simulate(False))
print("加锁(余量,成功数)", simulate(True))
(0, 2)先写回的是甲还是乙会随调度改变。两者都已经通过检查,所以结果都是确认两笔。
(0, 1)先拿到锁的一方在锁内完成读取、检查和扣减。另一方拿到同一把锁时重新读取,看到余量为 0,直接返回失败。
两个线程在取得锁之前等 ready。持锁时不等屏障,否则另一个线程可能正等同一把锁,两个线程谁也到不了下一步。屏障最多等待 5 秒,缺少参与者会报错。result() 把工作线程的错误带回调用方。这个上限只用来让演示能退出。Python 文档 · Barrier
这段锁保护的是整组读 → 查 → 改。只把写回包进去,第二笔仍会用旧值确认。所有可能改变库存或依赖这个检查的并发路径都应遵守同一把锁。示例在两笔都完成后才读取最终余量。
🔎 可选深入:锁保护状态,队列把完成交回主线程
前面的读改写例已经说明 GIL 不保护业务不变量。再按用途选机制:
| 机制 | 本页需要区分的语义 |
|---|---|
| Lock / RLock | 互斥访问共享状态;RLock 允许同一线程重入,但仍须配对释放。Lock 不因此变成“再拿一次也没事” |
| Condition | 拿着关联锁检查条件,wait 时释放它,醒来后重新拿锁并循环检查;收到通知不等于业务条件永久成立 |
| Event / Semaphore | Event 保留一个通知标志,不计每次脉冲;Semaphore 维护许可计数,适合限制并发数量 |
| Queue | 把数据和交接同步放在一处,适合 worker 完成通知;不同 worker 的结果要保留任务身份 |
# Python 3.13/3.14:worker 发送结果,主线程接收后调用方法
from queue import Queue
from threading import Thread, current_thread, main_thread
def worker(done):
try:
result = sum(range(4))
except Exception as exc:
done.put(("error", type(exc).__name__))
else:
done.put(("ok", result))
def on_done(value):
assert current_thread() is main_thread()
print("main received", value)
def main():
done = Queue()
thread = Thread(target=worker, args=(done,))
thread.start()
kind, payload = done.get(timeout=5) # 本小例等待界限,不是业务 SLA
thread.join()
if kind != "ok":
raise RuntimeError(payload)
on_done(payload)
if __name__ == "__main__":
main()
# 预期 main received 6;不在 worker 内直接调用 on_donejoin 是等待,不是把回调搬到主线程。小例由主线程取消息,再显式执行 on_done;若用 Future 回调,也不能仅凭“注册了回调”就断言它在主线程运行。若题目实际指子进程而非子线程,则改用进程间队列/管道协议,不能拿普通 queue.Queue 跨进程共享。
死锁先看等待关系:线程 A 持有互斥资源 L1、等待 L2;B 持有 L2、等待 L1。四个必要条件是互斥、持有并等待、不可抢占、循环等待。对于 OS 支持的互斥锁,这个等待环也会让对应原生线程无法前进;本例只画等待关系,不实际挂死程序。
本章已有的 POSIX 多线程 fork 警告是另一条具体链路:子进程只保留调用线程,却继承锁状态,原持锁线程不在子进程中,后续获取该锁可能永远等待。须按目标平台的 fork/线程约束选择启动上下文与收尾路径,不能把“换个 GIL”当解法。
处理时先确认等待链:统一取锁顺序、缩短持锁区属于预防;超时后必须按协议释放已持资源并撤销未完成动作,不是“有 timeout 就自动解锁”。若只能终止/重启隔离 worker,应先承认可能丢失未提交工作并安排恢复;不要强放别人的锁来跳过未完成的不变量。这里不扩展成内核锁实现或完整死锁检测专题。
🗓️ 九、GIL 会消失吗(这一节会过期)
CPython 3.13 提供了实验性的自由线程(free-threaded)构建。3.14 正式支持这一可选构建。PEP 779 · 自由线程的支持状态
导入 sysconfig 后,sysconfig.get_config_var("Py_GIL_DISABLED") == 1 为真,表示当前解释器来自支持自由线程的构建。
导入 sys 后,sys._is_gil_enabled() 返回 True 表示当前已启用,返回 False 表示当前已关闭。
即使安装了自由线程构建,也可能通过 PYTHON_GIL 或 -X gil 开启 GIL。导入未标记为支持自由线程的 C 扩展也可能重新开启它,所以应在加载实际依赖后再核对运行状态。关闭 GIL 后,纯 Python 线程可在不同核心同时运行,收益仍取决于工作划分、争用和硬件。Python 3.14 自由线程指南
切换构建时,分别检查解释器、扩展和仍然要付的成本。
| 理由 | 说明 |
|---|---|
| 安装选项 | CPython 3.14 仍把自由线程作为可选构建。先检查本机实际安装的版本与构建。 |
| C 扩展要重新适配 | 某个扩展能否安装、运行时是否重新开启 GIL,要按实际包版本和构建检查。 |
| ⭐ 本章的账不会全部作废 | 关闭 GIL 后仍需计入 pickle、进程启动和 spawn 导入开销。内置容器即使对单次操作有内部保护,也不会自动把一次预约的读取、检查和扣减合成一个操作。 |
📋 把本章规则当作选择起点:在启用 GIL 的 CPython 中,结合等待/计算、具体操作是否释放 GIL、共享争用及启动/搬运成本评估线程或进程;不按“放锁用线程、不放锁用进程”作唯一答案。free-threaded 构建须重新评估这些条件与同步责任,不能沿用受 GIL 约束的选型结论。
📋 十、一张排查表
| 现象 | 大概率是哪一节 | 一行验证 |
|---|---|---|
| 开了 8 个线程,CPU 占用还是只有一个核 | 一、二 —— 可能是启用 GIL 的 CPython 中解释器计算受锁约束;单核占用也可能来自其他串行瓶颈。 | 核对具体操作和类型的实现;串行、线程、进程作同负载对照并计入启动/传输,进程更快也不能单独证明原因是 GIL。 |
| 开线程反而更慢 | 二 —— 可能有锁与切换、共享争用或带宽等净开销,须按具体负载定位。 | 和串行比,不要和「期望值」比 |
| 同事说线程池管用,我这儿不管用 | ⭐ 三 —— 可能是操作、数据类型、GIL 行为或其他争用/开销条件不同,不能仅由收益差异判定。 | 先核版本/类型/实现,再作同输入串行与四线程计时;倍数只描述收益,不反推锁状态。 |
| 4 个进程比串行慢十几倍 | ⭐ 六 —— pickle 的账 | len(pickle.dumps(arg)) 看要搬多少 |
BrokenProcessPool |
⭐ 五 —— 没写 if __name__ == "__main__" |
往上翻栈,找 bootstrapping phase |
| 顶层的模型加载被执行了 5 次 | 五 —— spawn 会重新 import 主模块 | 在顶层打一行 print(os.getpid()) |
Notebook 里 num_workers>0 卡死 |
七 —— 没有可 import 的主模块文件 | 先设 num_workers=0 确认是不是它 |
| 计数器 / 缓存偶尔少几条,重跑就好了 | ⭐ 八 —— GIL 不保证你的代码线程安全 | 先画出两次读写怎样交错,再用预约例的屏障固定出错顺序。 |
🔗 这一章连到哪里
| 相关的地方 | 为什么 |
|---|---|
| 05 · 怎么量:计时、剖析、内存 | 本章每一个结论都是量出来的。⭐ 在选并发方式之前,你得先知道时间花在哪 —— 那一章讲怎么把「串行/线程/进程各测一遍」这件事做对(预热、取最小值、别被缓存骗) |
| 01 · 名字、对象和绑定 | 同进程的线程可以访问同一个对象。经进程池序列化传参通常会在另一进程重建对象。显式共享资源的边界见本章的进程通信补充。 |
| AI全栈 03 · 后端骨架 | async 的语法、事件循环怎么转、为什么别在协程里做阻塞调用,全在那里。⭐ 它把「真 CPU 活」指向了线程池或独立进程,本章第三节补上「什么时候该选哪个」的判据 |
| AI全栈 11 · 长任务与队列 | 本章讲的是一个进程内怎么并发。活如果长到分钟级,正确答案既不是线程也不是进程池,而是把它扔进队列 —— 那是那一章的正题 |
| AI基础设施 22 · 数据管线与存储 | num_workers / prefetch_factor / pin_memory 具体调多少在那里。⭐ 本章负责的是为什么它在 Windows 上一跑就炸 |
| 机器学习与深度学习基础 15 · PyTorch实战手册 | 训练脚本的骨架在那里。⚠️ 把它抄进本地脚本时,记得把训练循环放进 if __name__ == "__main__",否则 num_workers>0 一开就是本章第五节那个报错 |
| 07 · 异常、traceback 和调试 | 第五节那个 BrokenProcessPool 是「表层异常盖住根因」的典型样本,那一章讲怎么系统地往下扒 |
✅ 检查点
- GIL 用一句话说是什么规则?为什么 CPython 需要它(和哪个内存管理机制有关)?
- 8 核机器上,4 份纯 Python 的 CPU 活开 4 个线程,实测结果是什么?为什么会这样?
- 为什么「CPU 密集就开进程」太粗?应结合哪些操作、类型、GIL 与成本条件?原 float
np.sort和json.loads负载的实测倍数分别是多少,为什么不能直接推广? - 本章
sleep(0.25)与asyncio.sleep(0.25)等待示例中,线程和 async 怎样交错等待?原记录 8 个任务串行和 8 线程分别是多少?为什么不能据此规定固定连接数分界? - spawn 和 fork 的三个关键区别是什么?为什么在 Windows 上「顶层加载模型」这件事特别贵?
- 少写
if __name__ == "__main__"会怎样?为什么这个错误难查(你在终端里先看到的是哪条消息)? - 什么情况下 4 个进程会比串行慢?本章那个例子慢了多少倍?给出一条能算的规矩,以及避开的办法。
- 既然有 GIL,为什么
total = plus_one(total)还会丢更新?为什么几次正常结果不能排除竞态? DataLoader(num_workers=4)在 Notebook 里卡死,根因是什么?persistent_workers=True省掉的是哪一笔钱?- 怎样分别检查自由线程构建与当前 GIL 状态?关闭 GIL 后,哪些并发成本和同步责任仍然存在?
👀 答案
- 在启用 GIL 的 CPython 中,同一解释器里,同一时刻只有一个线程能执行 Python 字节码。 它存在是因为 CPython 用引用计数管内存——几乎每条字节码都要加减对象上的计数器,两个线程同时改会导致重复释放或永不释放。给每个对象配锁在技术上可行,但会让单线程程序显著变慢,GIL 是「一把大锁换掉几亿把小锁」的折衷。
sys.getswitchinterval()(原记录为 0.005 秒)给出目标切换间隔,实际间隔可能更长;它不保证每 5 毫秒交锁或发生 OS 切换,后续调度由操作系统决定。同一解释器内执行 Python 字节码仍是轮流跑。 - 串行 0.56 s、4 线程 0.73 s、4 进程 0.38 s —— 开线程比串行还慢,慢的是抢锁和切换的净开销,活一点没少干。进程那档只快 1.5 倍而不是 4 倍,因为起 4 个进程本身就要 0.387 s(同样的空任务开 4 个线程只要 0.002 s,差近 200 倍)。
- 在启用 GIL 的 CPython 中,要按具体操作、数据类型和实现核对计算期间是否释放 GIL;“有没有构造 Python 对象”不是等价判据。原记录中,
np.sort排 800 万个 float:串行 0.80 s → 4 线程 0.25 s(3.2 倍);json.loads解析 13.7 MB:1.51 s → 1.45 s(1.04 倍)。这些仅是该次负载的计时,不证明全程锁状态,也不推广到 object dtype 或其他实现。 - 在本章
time.sleep等待示例中,阻塞等待区段释放 GIL,任务可以重叠等待;asyncio.sleep由事件循环挂起和恢复任务。原记录串行 2.00 s、8 线程 0.25 s(正好 8 倍)、async 0.27 s,只描述这组负载。不能规定“几千连接”才出现区别;原文线程几百 KB 到几 MB 的栈、协程几 KB 是实现相关量级,实际容量仍须测量。 - ① fork 是复制当前进程、spawn 是从零启动一个新解释器;② fork 的子进程能看见父进程的全部内存,spawn 的什么都看不见,只有被 pickle 传过去的东西;③ spawn 会把主模块重新 import 一遍,所以顶层代码会重跑。Windows 与这里对照的 macOS 3.13/3.14 默认 spawn(原 Windows 3.13 记录中
get_all_start_methods()只有['spawn']);Linux 等 POSIX 的默认值须区分 3.13 的 fork 与 3.14 支持条件下的 forkserver,先查本机上下文。因此顶层写的加载模型 / 连数据库 / 读大 CSV 会被乘以进程数 —— 本章那个例子里[模块顶层]打了 3 次(1 个主 + 2 个子)。 - 子进程重新 import 主模块时会再次执行创建进程池那一行,无限递归。CPython 会抛
RuntimeError: An attempt has been made to start a new process before the current process has finished its bootstrapping phase。⚠️ 难查是因为你在终端里先看到的是BrokenProcessPool: A process in the process pool was terminated abruptly—— 字面像资源不足,真正的RuntimeError被埋在一堆multiprocessing/spawn.py栈帧中间;在 Notebook / IDE 里子进程的 stderr 常常根本不显示。 - 当搬数据的钱超过并行省下的钱时。本章例子:4 份 64 MB 数组只求个和,串行 0.036 s、4 进程 0.870 s,慢了 24 倍(pickle 一份就要 0.055 s,而计算只要 0.009 s)。“10 倍”仅是未经本轮基准验证的经验启发,不是通用门槛;实际比较要计入启动、导入、双向序列化、传输和任务/池复用的端到端成本。避开办法是 别传数据,传「去哪拿数据」(文件路径、行号区间、分片编号),大数组可以用
multiprocessing.shared_memory只传名字。 - 读取和写回之间可以夹进另一线程的操作。两个线程若读到同一个旧值,就可能各自写回同一个新值,使一次更新丢失。原记录依赖调度。预约例用屏障固定了同类交错,几次正常运行仍不能排除其他交错。
DataLoader(num_workers>0)就是一个进程池,spawn 要重新 import 主模块,而 Notebook 没有可 import 的「主模块文件」。修法是把 Dataset 类和训练循环挪进.py再 import,或者在 Notebook 里用num_workers=0。persistent_workers=True省的是 每个 epoch 重建 worker 的进程启动钱(本机 4 个空进程就要 0.39 s,import torch之后更贵)。Py_GIL_DISABLED的构建值为 1 表示支持自由线程。sys._is_gil_enabled()则报告当前进程。关闭 GIL 让纯 Python 线程可以并行,但仍需测量争用与收益。进程启动、pickle、重新导入的成本以及共享状态的同步责任仍然存在。
先预测。 两个预约都在锁外读到 1,也都通过了检查。如果只给写回上锁,成功数会是多少?
👀 检查锁的覆盖范围
成功数仍是 2。写回虽然排队了,但两笔预约都在用旧值做决定。第二笔必须等第一笔完成扣减,再在同一把锁内读取和检查,才能看到余量为 0。
本节回顾
⚡ 走神救援
⭐ 在本章启用 GIL 的普通单解释器运行方式下,同一时刻只有一个线程能执行 Python 字节码。 它存在是因为 CPython 用引用计数管内存,几乎每条字节码都要加减计数器——拿一把大锁换掉几亿把小锁。
⚠️ 实测 4 份纯 Python 的 CPU 活:4 线程比串行还慢(慢的是抢锁和切换的净开销),4 进程只快一点点(起进程本身就很贵,而开线程几乎免费)。
⭐ 在启用 GIL 的 CPython 中,具体操作与类型确认释放 GIL 时,CPU 计算可评估线程池;Python 对象操作所需的锁与调用中的可释放区段要分别核对,还要看共享争用和开销。原
np.sort/json.loads倍数只是本章负载记录,不是库名或锁状态的通则。选择起点:异步 I/O 可评估 async,同步 I/O 可评估线程池;在启用 GIL 的 CPython 中,CPU 计算须核具体操作、类型与实现是否释放 GIL,不能按 numpy / torch / 压缩 / 哈希库名直接决定。纯 Python CPU 工作可评估进程池,并计入启动与搬运成本。原等待实验的结果及线程/async 差异只适用于记录的负载,不设固定连接数分界。
选了进程之后第二类坑是进程怎么诞生:Windows 与这里对照的 macOS 3.13/3.14 默认 spawn;Linux 等 POSIX 须区分 3.13 的 fork 与 3.14 支持条件下的 forkserver,先查本机。spawn 从零启动新解释器并把主模块重新 import 一遍——⭐ 进程之间不共享对象,第 01 章那套「两个名字指同一个对象」在这里全部失效。
⚠️ 少写
if __name__ == "__main__"会无限递归,而真正的RuntimeError被埋在栈中间,你先看到的是BrokenProcessPool——字面像资源不足,于是你会去查错地方。💀 pickle 的账更贵:几份大数组只求个和,4 进程比串行慢二十多倍。⭐ 不要背固定倍数门槛:在目标 Python 版本和启动上下文下,实测串行与进程池的端到端成本,区分启动/导入、双向序列化、传输、计算和池复用。
下一节 👉 05-怎么量:计时、剖析、内存.md