外观
开更多线程为何没有更快:threading、GIL 与共享状态
摘要
把日志统计改成线程池后,速度没明显提高,计数还出现丢失。本文面向已有编程经验的 Python 初学者,解释线程、GIL 与业务同步的关系,通过受控交错实验展示错误来源,再讨论并发选择和线上观察。
验证环境: Windows x64,CPython 3.14.0 常规 GIL 构建;同一独立示例亦已在 CPython 3.13.7 运行通过。屏障控制反例交错,正例断言完整锁范围下的结果,不靠偶然调度证明线程安全。
场景:线程数翻倍,吞吐不升,结果还错了
这是一个教学场景。日志工具原先顺序处理文件,后来用八个线程并行汇总。每个线程完成一批就更新共享字典的数量。小数据测试看起来正确,扩大负载以后出现计数少于输入条数;另一个版本把线程数继续增加,CPU 使用更高,却没有相应吞吐收益。
先把同一批日志放进两个独立判断:处理两条,计数是否真的增加二;处理相同工作,等待或计算是否重叠。前者用共享状态和允许交错解释,后者用执行约束与测量解释。GIL保护部分解释器内部状态,不把读旧值、计算、写回合成一个业务事务;锁排除了危险交错,也不能保证吞吐提高。后面的屏障和线程数矩阵分别兑现这两项,不让一份速度数字代替正确性证据。
本文主线是 CPython 3.14 常规 GIL 构建,示例采用标准库线程。free-threaded 构建单独说明,不根据版本号推断部署一定启用或禁用 GIL。官方 threading 文档讨论了常规 GIL 构建中计算与 I/O 任务的差异。
线程共享内存,也共享问题
线程(thread)是一个进程里的执行单元,各自有执行位置和栈,但可以访问同一进程中的对象。进程(process)拥有自己的地址空间和资源范围;两个普通进程里的同名字典并不自动指向同一个对象。线程适合协调多个需要重叠等待的任务,同时也让共享可变状态更容易出现竞争。
并发(concurrency)表示多个任务的生命周期有交叠;并行(parallelism)表示多个执行单元在同一时刻真实执行。单个处理器可以通过切换实现并发,多个核心可以支持并行。讨论线程加速前,先明确要重叠的是等待还是计算,不能把“创建了八个线程”当成“八份 Python 计算一定同时运行”。
CPU-bound(计算密集)任务的大部分成本在处理器运算,例如大量 Python 层解析、循环和对象操作。I/O-bound(I/O 密集)任务的大部分时间在等待文件、网络或外部服务。这个分类不是按函数名字确定:一个看似网络任务也可能花大量时间做压缩或序列化;一个数值任务的主要运算可能在释放 GIL 的原生扩展里完成。
所以应该测实际工作负载。把端到端墙钟时间、进程 CPU 时间和调用热点连接起来,判断瓶颈位置,再决定线程、进程还是异步。只用 sleep 能说明等待可以重叠,不能证明真实网络接口在相同连接限制和后端容量下也获得同样收益。
GIL 保护的层与业务需要保护的层
GIL(Global Interpreter Lock,全局解释器锁)在常规 CPython 中限制同一解释器内多个线程同时执行 Python 字节码,配合解释器内部对象管理与状态访问。某些 I/O 路径和扩展运算可以释放它,让其他线程获得执行机会。这解释了为什么计算密集的 Python 循环通常不能仅靠线程数利用多个核心,却仍可以用线程重叠某些等待。
这不是 Python 语言对所有实现的普遍要求。不同解释器、子解释器安排、扩展实现和构建模式都有自己的边界。也不是“持有 GIL 的线程永远运行到函数返回”:线程会因执行机制或等待交出机会,用户代码调用的动作还可能执行其他逻辑。
业务不变量(invariant)是操作前后必须保持的关系,比如“处理两条记录,计数增加二”或者“库存不会变成负数”。不变量可能跨越读取、检查、修改多个步骤。只保护某一个字典写入,并没有保护“读取旧值,再根据旧值写新值”这一完整关系。
race condition(竞争条件)意味着结果依赖执行者的交错。先预测两个线程都读到0以后,各写old+1,最后会是1还是2:两份old都为0,写回值都为1,后一写覆盖前一写,答案是1。单次字典赋值即使不破坏内部结构,也没有保住两个业务增量;需要保护的是读取旧状态到提交新状态的整段关系。
图表将在阅读到此处时加载…
这张图故意展示一个合法交错。证明存在错误不需要宣称“每次运行都错”,也不需要依靠调度概率。正例应通过同步协议排除这类交错,使正确性不再依赖运气。
最小实验:让丢失更新稳定出现
保存以下代码为 docs/python/examples/19_threads.py。Barrier(屏障)让两个线程都读到旧值后才允许继续写入,受控地复现丢失更新。Lock(互斥锁)则让一段临界区同一时刻只有一个执行者进入。
python
"""Force a read-modify-write interleaving, then protect the whole invariant."""
from concurrent.futures import ThreadPoolExecutor
from threading import Barrier, Lock
import time
import platform
def cpu_work(_):
return sum(i * i for i in range(50000))
def wait_work(_):
time.sleep(0.01) # Controlled waiting, not real network throughput.
return 1
def main():
shared = {"count": 0}
barrier = Barrier(2)
def wrong():
old = shared["count"]
barrier.wait(timeout=5) # Both workers must read before either writes.
shared["count"] = old + 1
with ThreadPoolExecutor(max_workers=2) as pool:
futures = [pool.submit(wrong) for _ in range(2)]
for future in futures:
future.result(timeout=10)
assert shared["count"] == 1
print("unprotected:", shared["count"])
shared["count"] = 0
lock = Lock()
def correct():
with lock: # Lock covers reading, deciding and writing.
shared["count"] = shared["count"] + 1
with ThreadPoolExecutor(max_workers=2) as pool:
futures = [pool.submit(correct) for _ in range(2)]
for future in futures:
future.result(timeout=10)
assert shared["count"] == 2
print("protected:", shared["count"])
print("timing environment:", platform.platform(), platform.python_version())
for function in (cpu_work, wait_work):
start = time.perf_counter()
expected = sum(map(function, range(8)))
baseline = time.perf_counter() - start
for workers in (1, 2, 4):
start = time.perf_counter()
with ThreadPoolExecutor(max_workers=workers) as pool:
result = sum(pool.map(function, range(8)))
assert result == expected
print("matrix:", function.__name__, workers, "sequential_s", baseline,
"thread_s", time.perf_counter() - start)
if __name__ == "__main__":
main()powershell
python docs/python/examples/19_threads.py屏障先让两份old同时成为0,再放行写回,反例确定得到 unprotected: 1;重置count为0后,正例把读改写一起放进锁,第二线程只能在第一线程写成1后读取,最终 protected: 2。实测与断言核对这条状态轨迹,不是自然调度的错误概率实验。证明允许一条错误交错已经足够,修复则必须排除这条交错,而非期待测试多跑几次。
注意正例没有把屏障放进锁内部。如果第一个线程持锁等待第二个线程到达屏障,而第二个线程又必须先获取同一把锁,实验会自己制造死锁。屏障用于建立实验交错,互斥用于排除生产逻辑中的危险交错,两者职责不同。
每个 future 都调用 result,这样工作线程异常会传回主线程,验证不会只看到部分打印却漏掉失败。线程池通过上下文退出完成工作与回收。屏障和结果等待都有界限,避免错误代码让教学程序无限挂起。
锁应该覆盖什么,不应该覆盖什么
临界区(critical section)是访问共享状态、必须相互排斥的一段逻辑。锁范围要覆盖完整不变量,不能只在最后赋值时加锁。库存检查、扣减和关联状态变更需要按真实业务关系组织,否则读到的前提在等待期间已失效。
但临界区过大也有成本。持锁进行慢网络调用,会把本来可以重叠的任务串起来,还可能导致所有等待者堆积。常见改法是在锁内提取必要状态和建立所有权,锁外完成耗时工作,再按版本号或其他协议验证提交条件。这个拆分不能盲目套用:外部操作可能不可撤销,需要业务幂等与状态机共同设计。
Lock 和 RLock 的选择也来自调用关系。RLock 是可重入锁,同一线程可以重复进入,但必须对应释放;它方便存在合法嵌套的封装,不能修复两个线程形成的锁顺序环。若一段代码无意递归获取普通 Lock,会挂住;改成 RLock 之前仍要确认递归访问是否本来合理。
死锁(deadlock)通常表现为执行者互相等待而无法推进。统一多把锁的获取顺序、减少同时持锁、显式超时与故障处理可以降低风险。超时仅让调用方有机会离开等待,不保证状态自动回滚,也不能把锁获取失败当成已经完成业务。
条件变量(Condition)适合等待某个状态谓词成立。等待时应在循环中检查条件,因为一次通知不等于你需要的状态永久有效。Event 适合表达某个信号,Semaphore(信号量)适合限制可同时使用的资源数量;Queue(队列)则把生产和消费组织成数据交接。选工具时先写状态关系,再选名字。
更常见的正例:减少共享写入
仍然统计同一批日志,再换一项所有权安排:线程各自产生局部计数字典,归并者逐项相加。工作阶段不再共同读改写同一个count,前面的危险交错失去共享目标,正确性更容易检查。性能是否改善要另测锁竞争与归并成本,不能从“没有锁”直接推导快。这个结构还能迁移到多进程,区别是局部结果需要序列化返回,通信费用也进入总成本。
如果多个线程要处理一批任务,可以使用有容量限制的队列建立生产、消费和退出协议。队列负责安全交接任务,不负责限制外部服务的所有资源,也不保证业务任务只执行一次。重复消息、失败重试和半完成状态仍要由应用层处理。
对线程池而言,限制 max_workers 不等于提交队列有业务上限。生产速度持续超过处理速度时,待执行任务及其参数可能积累,内存上涨。背压(backpressure)指下游容量不足时限制上游继续生产,必须覆盖提交和数据读取两侧,不能只控制正在运行的线程数。
线程局部状态可以用于某些按线程拥有的资源,但不是请求隔离的普遍替代。线程池会复用线程,请求结束后的状态可能被下一请求看到;异步任务还可能在同一线程中交错。需要请求上下文时,应明确上下文的创建、传播与清理协议,而不是猜测线程数量和请求数量相同。
free-threaded 构建:并行能力增加,同步责任仍在
Python 3.14 对 free-threaded 构建提供官方支持,但常规构建并没有因此自动移除 GIL。free-threading 官方说明讨论了构建识别、扩展兼容、线程安全与性能代价。某些不支持该模式的扩展可能使 GIL 重新启用,所以“安装的是自由线程版本”还不足以证明当前进程正在无 GIL 模式运行。
在没有 GIL 的模式下,内建类型可使用内部同步维护对象一致性,但这仍不是多步业务不变量的锁。官方建议应用使用显式同步,避免依赖偶然的内部实现细节。本文的屏障反例针对算法交错,在常规构建和自由线程思路下都说明同一个逻辑缺口;不同构建的具体执行和性能必须分别验证。
自由线程有额外对象管理和同步代价,不同负载可能表现不同。不能宣称“去掉 GIL 一定线性加速”,也不能把某个单线程负载退化比例复制到所有服务。应在真实扩展组合、数据规模、核心数和内存限制下建立基线,同时验证正确性。
线上如何识别线程问题
看到 CPU 高,先区分一个核心长期忙、多个核心忙,还是很多线程频繁等待与切换。进程 CPU、线程 CPU 和栈采样应互相解释。大量线程在 Lock.acquire 或队列等待,未必是异常:空闲消费者本来就会等任务;要结合请求是否堆积和资源所有者是否推进判断。
遇到计数不一致,先寻找共享可变对象和复合操作,再用受控交错写出最小复现。单纯重跑一千次都通过,不能证明没有竞争条件;强行增加 sleep 可以帮助复现,但要解释它制造了哪一个交错,不能把偶然延迟当成修复。
日志也不应该成为新的锁热点。多个工作线程频繁输出大量文本,会改变调度和耗时,排查结果可能不代表原负载。保留请求标识、线程身份和关键状态变更即可,需要长时间观测时使用适当缓冲或异步采集策略,并评估其自身容量。
原子性、可见性与顺序:把承诺说到准确范围
atomicity(原子性)表示在相应观察范围内,一个操作不可被分割成可见的中间状态。这个范围需要明确:某个内建 API 维护内部结构,不意味着业务上一组 API 变成一个不可分割动作。if key not in cache 接着 cache[key] = create() 即使每个容器动作本身有保证,两个线程仍可能同时创建资源。
visibility(可见性)讨论一个执行者写入后,其他执行者在什么条件下可以观察到。ordering(顺序)讨论多个动作的先后约束。Python 应用通常应依赖明确的同步 API 和其契约,不应该凭 CPU 指令或当前字节码推测全部并发语义。锁、事件与队列不仅表达互斥,也表达程序双方约定的交接点。 可进一步阅读JMM与happens-before:Java happens-before规则不能当Python运行时保证。
例如生产者先完成结果构造,再把结果放进线程队列,消费者从队列取得后使用,是明确的交接协议;生产者交接后又继续修改同一可变结果,就把所有权重新变模糊了。队列让传递动作可协调,不能自动把传入对象变成不可变快照。这个区别在线程里比进程里更直接,因为传递后仍可能共享同一对象。
对缓存“只初始化一次”的需求,可以在锁内检查并创建,或者使用明确状态机把创建中的等待者组织起来。若创建是慢 I/O,全部持锁等待会阻塞其他键,也可能失败后留下不完整状态。正确方案要定义创建失败如何通知、状态如何重置,以及等待者是否重试,不能只把几行代码包进锁就认为工程问题结束。
线程停止:请求结束与底层工作结束的差别
普通线程没有安全通用的强制终止任意执行代码的协议。协作停止通常用 Event、队列结束标识或相应库的超时机制,让线程在合适位置检查并退出。调用方等待超时后离开,工作线程仍可能继续使用连接和缓冲,下一轮提交会增加积累。
因此应用要有任务所有者:谁设置停止信号,谁观察最终异常,谁等待清理完成。join 等待线程结束,不会自动发送停止请求;守护线程只是影响进程退出时是否等待它,不保证事务、文件或外部状态已经清理。后台任务关键资源应有可验证的关闭路径。
线程池里的 future 可以取消尚未开始的任务,但不能据此假设已运行函数被杀掉。若函数正在网络等待,库级 timeout 和主动关闭能力决定它何时返回;若长期计算,则需要在工作单元边界检查协作信号。把等待预算、工作预算和资源关闭三件事区分开,才能解释“请求已超时,线程数却仍增长”。
压力测试为什么不能替代正确性推理
重复负载测试可以发现实际竞态,却不能覆盖所有交错。当前构建、日志和机器速度可能一直让读取与写入紧靠一起,错误长期不出现;换扩展版本、加一次 I/O 或迁移机器后才暴露。正确性需要写出状态关系,并由同步协议排除不允许的交错。
将压力测试接回状态模型:屏障说明算法允许两份旧值共存,锁协议说明该危险路径被排除;之后相同负载的矩阵才用来检查性能和资源。改构建、扩展或机器可能改变自然交错概率,但不改变这份业务前提。保留模型与测量两份证据,才能解释为何“连续一千次正确”和“当前快了一点”都不能单独建立线程安全承诺。
对照实验的下一步:归并与锁竞争
读者可以把共享计数改成每个工作线程返回局部结果,主线程求和,保持输入和结果不变再测耗时。若共享更新很频繁,归并能减少锁竞争;若主要时间在外部等待,差异可能很小。这个结论必须从相同负载得到,不能从“没有锁”直接推断“一定更快”。
也可以记录获取锁前后时间,区分临界区执行与锁等待。计时和日志本身会改变调度,应减少高频输出并报告测量方式。等待大不一定要删除锁;锁保护的是正确性,优化目标应是缩短必要范围、分片状态或减少共享,而不是把保护移除后追求漂亮数字。
容易踩的坑与面试追问
第一个坑是把 counter += 1 在当前版本偶然表现正确,解释成语言保证。表达式涉及对象协议和执行细节,不应该替代同步协议。第二个坑是吞掉线程异常,只检查主线程是否退出;future 的异常必须被消费,守护线程提前结束也不能证明任务完成。
第三个坑是在线程池工作线程里提交另一个同池任务并等待它。如果所有工作线程都在等待还没开始的子任务,线程池无法推进。解决方向是改变任务依赖和归并结构,或使用适合的调度方式,不能靠无限增大线程数长期掩盖。
面试问“GIL 是否让 Python 线程完全没有价值”,应从等待重叠、释放 GIL 的扩展和协调用途回答。问“字典线程安全意味着什么”,应区分内部一致性、单次 API 保证和复合业务关系。问“线程数该设多少”,应先回答资源容量、任务耗时分布和服务目标,再通过受控负载测量选择。
线程数量对照:正确性证明与计时证据分开
线程数对照对八个固定工作单元分别比较顺序、1、2、4 个线程;CPU 工作每单元累加 50000 个平方,等待工作每单元 sleep(0.01)。完整用时包含线程池创建与归并,程序打印环境及原始秒数,并断言结果相同。sleep 只是受控等待,不代表真实网络、连接池或数据库服务。次数很少,计时受机器负载与调度影响,不输出通用加速承诺。
同一工作量的线程曲线让两个假设可以分开:CPU 工作是否被传统 GIL 解释器限制、独立等待能否重叠。它不证明所有 CPU 工作都无法在线程中并行,因为原生扩展可能释放 GIL;也不证明提高线程数始终有利,真实下游可能先耗尽连接预算。机器上可运行的逻辑 CPU 数只是环境信息,不是可用 CPU 配额。
与 Java 线程安全保护什么比较的是业务不变量覆盖范围,不能套用 Java Memory Model 的同步保证。CPU 时间与经过时间的差异进一步见 OS 调度与上下文切换。需要独立解释器的 CPU 工作转到 多进程粒度,其通信费用必须纳入计时。
能力任务:给工作单元增加共享统计,制造一次受控读改写交错,再修复;提交正确性断言及同输入线程数矩阵。验收不能拿“计时变快”抵消丢失更新,也不能拿“结果正确一次”证明没有竞态。
一句话总结:GIL 约束部分解释执行,业务正确性仍由完整同步协议保证。
- 区分计算、等待、并发和并行,再决定线程是否适合工作负载。
- 锁覆盖不变量,减少共享写入通常更容易维护和验证。
- 构建模式、扩展兼容和补丁行为都要实查,不能凭版本号推断并行能力。