一个同事想把报表计算加速,开了两个线程各算一半。他预期时间减半,实测却从 0.42 秒变成 0.50 秒,反而慢了一点。代码没有 bug,线程也真的并发了,问题出在 Python 的全局解释器锁上。
我用一段纯计算做了对比:单线程连续算两次平方和,耗时 0.429 秒;两个线程各算一次,耗时 0.502 秒。同一台机器、同样的计算量,多线程更慢。原因不是线程切换本身,而是同一时刻只有一个线程能执行 Python 字节码,另一个只能在旁边等,切换还要花额外的时间。
但换成等待场景,结论立刻反过来:四个线程各睡 0.5 秒,总耗时 0.511 秒,几乎等于一个线程的等待时间。因为 sleep 会释放 GIL,四个等待可以重叠。这就是 Python 多线程的适用边界:CPU 密集不划算,I/O 等待才划算。这篇把 GIL、锁、队列和线程异常讲透。
GIL 到底锁住了什么
GIL 是 CPython 解释器实现里的一把全局锁,保证同一时刻只有一个线程执行 Python 字节码。它保护的是解释器内部状态,比如对象的引用计数,不是你的业务数据。换句话说,GIL 让「解释器不会因为多线程改坏对象结构而崩溃」,但不保证你的「读-改-写」是原子的。
很多人以为有了 GIL 就不用加锁,这是误解。GIL 只保证单条字节码执行时不被别的线程打断,一个业务操作通常由多条字节码组成。比如 counter += 1 至少包含读取、加法、写回三个步骤,中间可能发生线程切换,另一个线程也读到旧值,最后两次写回覆盖,结果少加一次。
counter = 0
def slow_inc():
global counter
for _ in range(5000):
v = counter
time.sleep(0.00001)
counter = v + 1
两个线程各跑 5000 次,预期 10000,实测结果是 5000。每一次「读出来、等一会、再写回」都被另一个线程完整插入,几乎所有更新都丢了。真实业务里不一定会 sleep,但只要有网络请求、磁盘读写、日志写入,效果一样。
切换间隔默认是 5 毫秒,可以用 sys.getswitchinterval() 查看。这个值意味着一个线程最多连续跑 5 毫秒就让出,但「让出」不等于「立刻切到另一个线程」,还要看操作系统调度和锁竞争。把间隔调得很小会增加切换开销,调得很大会让交互变迟钝,默认值通常是平衡点,不要随手改。
GIL 也不是 Python 语言规范。它是 CPython 的实现细节,其他实现(比如 Jython)没有;较新的 CPython 版本已经在实验「自由线程」构建,去掉 GIL,但生态兼容和性能仍在演进。写业务代码时按「有 GIL」的假设设计,同时别把 GIL 当成数据安全的保证。
threading 的基本用法
创建线程有两种方式:传一个可调用对象给 Thread(target=...),或者继承 Thread 重写 run。前者更常用。线程用 start() 启动,join() 等待结束。不 join 的话,主线程可能先退出,非守护线程会阻止进程结束,守护线程则会被直接终止。
def sleep_task():
time.sleep(0.5)
threads = [threading.Thread(target=sleep_task) for _ in range(4)]
start = time.perf_counter()
for t in threads:
t.start()
for t in threads:
t.join()
print(round(time.perf_counter() - start, 3))
输出 0.511。四个线程的等待重叠了,总时间接近单个等待。这就是线程池在 I/O 场景里的价值:不用为每个任务创建进程,切换成本低,等待可以重叠。
守护线程用 daemon=True 设置。它的特点是主线程退出时不等它,进程直接结束。后台心跳、定时清理可以用守护线程,但涉及「必须写完数据」的任务不能用,因为主线程一退,它可能在任何位置被切断。需要保证完成的工作,老老实实 join。
threading.current_thread().name 能拿到当前线程名,日志里带上它,排查多线程问题时至少知道是谁打的。threading.enumerate() 列出所有活着的线程,卡死时用它看还有谁在跑。这些信息比「程序没反应」有用得多。
竞态:从「读改写」到「先检查再操作」
竞态不只有计数器。更常见的是「先检查再操作」:
if key not in cache:
cache[key] = load(key)
两个线程同时判断 key 不存在,都去加载,都写回,最后一次覆盖前一次。结果不一定错,但加载被做了两次,下游可能被重复调用。缓存击穿、重复下单、重复发消息,都是这个模式。修法要么加锁把「检查加写入」变成一个原子段,要么用「只允许一个线程加载」的机制,比如 threading.Lock 配合二次检查。
锁的基本用法是 with lock:,进入时获取,退出时释放,异常也会释放。手动 acquire / release 容易在异常路径上漏掉,除非确实需要跨函数持有,否则不要手写。锁的粒度要小:只包住真正需要互斥的几行,不要把网络请求、文件读写包在锁里,否则所有线程都排成一队,多线程退化成单线程。
死锁最常见的来源是「两个锁,不同顺序」。线程 A 先拿锁 1 再拿锁 2,线程 B 先拿锁 2 再拿锁 1,两边各持一个等另一个,永远解不开。预防办法是全局约定获取顺序,或者用带超时的 acquire(timeout=...),失败就放弃并重试。项目里锁的数量要控制,锁越多,顺序越难保证。
除了互斥,threading 还提供几种协作原语。Event 是一个布尔标志,一个线程 set,其他线程 wait,适合「通知所有后台线程停止」;Condition 让线程在某个条件不满足时等待,条件满足时被唤醒,适合生产者消费者之外更复杂的等待;Semaphore 是一组计数许可,限制同时访问某种资源的线程数,比如最多四个线程同时调用外部接口。
这些原语的共同点是「等待会释放锁并让出执行权」,比手写「循环检查标志位」省 CPU。用 while flag: pass 忙等的代码,看起来简单,实际上占满一个核,还会拖慢其他线程。需要等待就用 Event.wait 或 Condition.wait,带上超时,避免永久阻塞。
RLock 是可重入锁,同一个线程可以多次获取而不死锁。它适合「一个加锁的方法调用另一个加锁的方法」的场景,但也会掩盖设计问题:如果锁的边界清楚,通常不需要重入。用 RLock 前先问一句「为什么同一段逻辑会被嵌套调用」,能拆就拆。
队列:比共享变量更好的选择
queue.Queue 是线程安全的 FIFO 队列,内置锁和条件变量。生产者 put,消费者 get,队列空时 get 阻塞,满了时 put 阻塞。它把「共享状态」变成「消息传递」,调用方不需要自己管理锁,出错概率低得多。
q = queue.Queue(maxsize=3)
def producer():
for i in range(10):
q.put(i)
q.put(None)
def consumer():
out = []
while True:
v = q.get()
if v is None:
break
out.append(v)
print(out)
maxsize 是背压:队列满了,生产者会被阻塞,不会无限往内存里堆任务。不设上限的队列在生产者快、消费者慢时会吃掉内存,最后进程被杀。给队列一个有界的容量,是流式处理里最简单有效的保护。
Queue 还有一个 task_done 和 join 的配套机制:每处理完一个任务调用 task_done(),join() 会等所有任务都被标记完成。我实测时只 get 不 task_done,队列的 unfinished_tasks 停在 11,此时调用 join() 会永久阻塞。这个坑在「优雅退出」的代码里很常见:消费者退出了,主线程还在等 join。
队列里放什么也有讲究。放不可变的小数据最安全;放可变对象要注意,get 之后对象就归消费者所有,生产者不要再改。放 None 作为结束信号是常见写法,但如果有多个消费者,一个 None 只能唤醒一个,需要给每个消费者都发一个,或者用 Event 统一通知。
queue.SimpleQueue 更轻量,没有 task_done 和 join,适合不需要完成确认的场景。LifoQueue 是后进先出,PriorityQueue 按优先级出队,任务调度里会用到。选哪种取决于「谁先处理」的业务语义,不要默认 FIFO 就够。
线程异常、退出与调试
线程里抛出的异常不会传回主线程。Thread.run 捕获后交给 threading.excepthook,默认打印到 stderr,然后线程结束。主线程的 join 只会返回,不会重新抛出。这意味着一个后台线程挂了,主流程可能毫无察觉,继续用不完整的数据往下走。
处理方式有三种:在线程函数里自己 try/except 并记录日志;设置 threading.excepthook 统一收集;或者用 concurrent.futures.ThreadPoolExecutor,它的 Future 会在 result() 时重新抛出异常。最后一种最接近「调用函数」的直觉,新代码优先用它,threading 适合长生命周期的后台线程。
ThreadPoolExecutor 的用法是提交任务拿 Future,future.result() 取返回值并重新抛出异常,as_completed 按完成顺序处理结果。线程数用 max_workers 控制,等待型任务可以比核数多一些,计算型任务开再多也不会更快。记得用 with 管理执行器,退出时自动等待任务结束,否则主线程可能先走,结果没人处理。
退出要设计。直接 sys.exit() 只会结束当前线程,不会结束进程;用 Event 或标志位通知线程停止,再 join,是更可控的方式。阻塞在 queue.get() 的线程收不到标志位,需要 get(timeout=...) 周期性醒来检查,或者往队列里放一个结束信号。
调试多线程程序,先看「谁持有锁、谁在等锁」。Python 没有内置的锁监视器,但可以在日志里记录 acquire 前后、线程名和时间。卡死时用 faulthandler.dump_traceback() 打印所有线程栈,能看到每个线程停在哪一行,比猜快得多。
日志本身也要考虑线程安全。标准库的 logging 内部有锁,单条记录不会交错,但「先判断再打印」的多行输出仍可能被别的线程插进来。需要一段完整输出时,用一把日志锁包住,或者把内容拼成一个字符串再一次输出。排查并发问题时,日志顺序不可靠,能记录时间戳和线程名就别省。
如果每个线程需要一份独立的状态(比如请求上下文、缓冲区),用 threading.local(),它会按线程隔离数据,互不干扰。不要把一个可变对象放在模块全局再让所有线程改,那种写法在测试环境往往看不出问题,一到并发就出现串数据。
现象对照
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 多线程算得比单线程还慢 | CPU 密集任务受 GIL 限制,切换还有开销 | 确认任务是计算型还是等待型,计算型换多进程 |
| 四个线程等待总时间和一个差不多 | 阻塞调用会释放 GIL,等待可以重叠 | 确认耗时在 IO 或 sleep,而不是纯计算 |
| 计数器少加 | += 是多条字节码,中间可能被切换 | 给读改写加 Lock,或用队列汇总 |
| 缓存被重复加载 | 「先检查再写入」不是原子操作 | 加锁或改成「只允许一个加载者」 |
| 程序卡住,CPU 为零 | 线程都在等锁或等队列,形成死锁 | faulthandler 打印线程栈,检查锁获取顺序 |
q.join() 永远不返回 | 只 get 没 task_done | 每个任务处理完调用 task_done() |
| 后台线程出错但主流程照常跑 | 线程异常不会传回主线程 | 线程内捕获记录,或改用 Future.result() |
| 进程退出时数据没写完 | 守护线程被直接终止 | 关键任务不要设 daemon,退出前 join |
| 锁里的请求越来越慢 | 锁粒度太大,把 IO 包进了临界区 | 缩小临界区,只包住共享状态的读改写 |
边界与代价
多线程的收益只来自「等待重叠」。判断标准很实际:把任务写成单线程跑一遍,看时间花在 CPU 还是等待上。用 time 或性能分析工具看,计算占大头就换多进程,等待占大头才用多线程或异步。凭感觉加线程,经常得到「更慢且更难调」的结果。
线程的代价是共享状态。所有线程共享内存,读写顺序不确定,锁用错就死锁或丢更新。把共享状态压到最小、用队列传递消息、让每个线程尽量处理独立数据,是降低复杂度最有效的办法。共享一个巨大的字典再到处加锁,通常是最差的设计。
调试代价也不低。断点会暂停所有线程,日志交错,时序问题难以复现。上线前把线程名、任务 ID、关键状态写进日志,出问题时才有线索。能复现的 bug 好修,偶发的竞态才最难,所以预防比调试重要。
和异步的关系也要说清:多线程由操作系统调度,切换时机不完全可控;异步由事件循环调度,切换点明确在 await。I/O 密集且连接数很多时,异步的资源开销更小;代码里已有大量同步库、改造成本高时,线程池更现实。两者不是替代关系,按场景选。
还要留意 Python 版本的变化。较新版本提供了去掉 GIL 的实验构建,多线程可以真正并行执行字节码,但需要专门的构建、第三方扩展也要兼容,性能和生态都还在演进。现有项目仍应按「有 GIL」设计。即使将来 GIL 消失,竞态也不会消失:多个线程同时读改写共享数据,照样需要锁,只是并行度提高了。把「GIL 保护我」当成设计前提,换版本时就会集中爆雷。
最后是平台与实现差异。GIL 的行为、线程调度、信号处理在不同平台和不同 Python 实现上不完全一样。跨平台项目要避免依赖「某个线程一定先跑」这类时序假设,用锁、事件、队列把顺序显式化。
小结
GIL 让同一进程内同一时刻只有一个线程执行字节码,所以 CPU 密集任务多线程不会变快,实测甚至更慢;阻塞调用会释放 GIL,I/O 等待可以重叠;GIL 不保护业务数据,读改写和先检查再操作都要加锁;锁要小粒度、固定获取顺序;线程间通信用队列,注意 maxsize、task_done 和结束信号;线程异常不会自动传回主线程,要自己捕获或用 Future。
写多线程代码前先回答一个问题:这段任务是「算」还是「等」?算用多进程,等用线程或异步。答错了,后面所有优化都是白费。线程池不是越多越好,并发上限要跟着下游容量走,不能只按本机核数拍板。
当天可以自己验证的练习:
- 写一个纯计算的函数,分别用单线程和两个线程跑,记录耗时,确认线程没有更快。
- 写四个
sleep(0.5)的线程,记录总耗时,确认等待可以重叠。 - 用「读出来、sleep、写回」的方式复现丢更新,再加
Lock跑一次对比数字。 - 用
Queue(maxsize=2)写生产者和消费者,观察生产者被阻塞的时机。 - 故意只
get不task_done,调用q.join()观察阻塞,再用task_done修好。
下一篇讲异步:asyncio、await、任务取消与超时。线程的切换由操作系统决定,异步的切换由你自己在 await 处决定。控制权更明确,代价是整条调用链都要改成异步,一处同步阻塞就会拖住整个事件循环。