← 返回首页

线程池、进程池还是协程:我在 16 核机器上跑完了同一份负载

Python并发性能实测

同事建议我给批处理脚本套一层 Celery,理由是「五万条任务,单线程跑不完」。我没急着装,先做了一件更便宜的事:把任务的耗时拆开看,到底是在等网络、在算 CPU,还是在等磁盘。三个答案指向三种完全不同的写法,而其中两种根本不需要队列。

这篇文章是我实际把同一份负载用四种跑法各跑三遍之后的结果。结论先说清楚:并发形态解决的是「等待」,不是「吞吐」;队列真正的价值是「活过重启」和「背压」,不是让程序变快。如果你的任务只需要前者,标准库三行就能解决,不需要任何中间件。

本文不含任何联盟推广链接。文中的数据全部在我本机跑出来,脚本原样贴出,你可以复现。

先把瓶颈量出来,再决定要不要队列

选形态之前,我只问三个问题,顺序不能换:

只有后两问指向队列,第一问决定的是「用线程、用进程还是用协程」。我见过最多的错误是:一个纯 I/O 任务,先套了一层消息队列,再在 worker 里开了 20 个线程,最后发现瓶颈是对端服务的 QPS 限制——三层并发全部压在同一个瓶颈上,只是把失败点推得更远。

我的量法与环境

环境是 Windows 11 + CPython 3.13.14 + 16 个逻辑核。负载是一个最小的 HTTP 服务端,跑在独立进程里,每个请求 time.sleep(0.003) 后返回 100 字节;客户端发 1500 次请求,每次新建连接(不做 keep-alive),这样连「建连 + 解析」的固定成本也算进去,更接近真实抓取脚本。

服务端独立进程这一点很重要。第一版我把服务端放在同一个进程的线程里,结果 20 个 worker 只跑出 4.5 倍加速——因为服务端和客户端在抢同一把 GIL,量到的不是客户端并发能力,是自己跟自己抢锁。

# 服务端(独立进程,端口 18765)
python bench.py serve
# 客户端:serial | thread N | queue N | asyncio N | proc N
python bench.py thread 20

每个形态都在独立子进程里跑,用 tracemalloc 记 Python 堆峰值。tracemalloc 只统计 Python 层分配,不含解释器与栈的常驻内存,所以下表的「峰值」是相对量,不能当成 RSS 读。

四形态对拍:加速比在 8 就封顶

每种形态跑 3 次取中位数,串行基线 14.547 秒:

形态中位墙钟每秒请求相对串行Python 堆峰值
串行14.547 s103.11.00x1.75 MB
线程池 26.386 s234.92.28x4.41 MB
线程池 43.131 s479.04.65x4.42 MB
线程池 81.587 s945.09.17x4.43 MB
线程池 161.712 s876.08.50x4.47 MB
线程池 201.776 s844.78.19x3.93 MB
线程池 321.687 s888.98.62x3.02 MB
线程池 641.733 s865.58.39x3.16 MB
队列 201.633 s918.58.91x1.89 MB
asyncio 202.229 s672.96.53x3.49 MB
进程池 2011.112 s135.01.31x2.55 MB

这张表里最该注意的是平台期:8 个 worker 之后,从 16 到 64 全部落在 1.59 到 1.78 秒这条窄带里,每秒请求在 840 到 945 之间横着走。也就是说,把 worker 从 8 加到 64 花了 8 倍资源,换来的吞吐差是 0。

原因不在客户端,在对端。服务端是一个单进程 Python 的 ThreadingHTTPServer,每个连接开一个线程,处理请求要抢 GIL——它能吐出的上限就是每秒 900 次左右。客户端无论 16 还是 64,都在等同一个天花板。

这就是「并发形态解决等待、不解决吞吐」的实证。加并发之前先问一句:瓶颈是在我这边,还是在对面?如果对面是个限流的第三方 API,你开 64 个线程只是把 429 的错误来得更早一点。

另外两个数字值得单独看:queue 形态(20 个长驻线程 + queue.Queue)比 ThreadPoolExecutor(20) 快 8%(1.633 对 1.776 秒),因为线程池的 submit 要为每个任务建一个 Future 对象、走一遍锁和条件变量,1500 次提交全是这种固定开销;asyncio 比线程池慢 36%,因为 HTTP 建连与解析本身是单线程 Python 在跑,协程省下的只是「等待」,省不掉 CPU 那部分。

默认 20 个 worker,比 8 个慢 12%

ThreadPoolExecutor() 不传参时的默认值,官方文档写得很清楚:3.8 改成 min(32, os.cpu_count() + 4),3.13 又把 os.cpu_count() 换成了 os.process_cpu_count()。本机 16 核,两种算法都给 20:

import os
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
print(os.cpu_count(), os.process_cpu_count())      # 16 16
with ThreadPoolExecutor() as ex:
    print(ex._max_workers)                          # 20
with ProcessPoolExecutor() as ex:
    print(ex._max_workers)                          # 16

默认值的用意是「至少给 I/O 任务留 5 个 worker,最多用 32 个核」,这是个上下限保护,不是性能最优解。本机实测:默认 20 跑 1.776 秒,手设 8 跑 1.587 秒,默认值比最优点慢 11.9%,三跑区间分别是 1.740 到 1.870 秒和 1.565 到 1.613 秒,不重叠,不是噪声。

这条对写脚本的人很实际:ThreadPoolExecutor() 空着参数写,在很多机器上意味着「比最优慢一成,而且你自己不知道为什么」。我的做法是先按 8 起手,任务里有明确的长等待(比如每次 2 秒以上的外部调用)再往上加,一次加一倍,看墙钟有没有真的降。加完不降,就是撞到对面的天花板了,加回去。

进程池做 I/O:慢 6.3 倍

上表最后一行是这篇文章里最贵的一课:20 个进程跑同样的 1500 次请求,用了 11.112 秒,只有串行的 1.31 倍——比线程池慢 6.3 倍,比串行也就快一点点。

原因有三层,都在进程池的设计里:

一是启动成本。Windows 默认的启动方式是 spawn,每个子进程都是一次完整的解释器启动 + 重新导入主模块,20 个进程就是 20 次。

二是每个任务的序列化成本。submit 要把函数和参数 pickle 进管道,子进程再 pickle 回来。任务本身只有 3 毫秒时,序列化和管道往返比干活还贵。

三是任务粒度。1500 个任务分给 20 个进程,每个进程 75 次往返,Executor.map 在进程池上默认 chunksize=1,固定成本被放大了 1500 次。

我用另一个实验把「启动与序列化」和「真正计算」拆开了:400 个每份约 0.9 毫秒的 sha256 任务,串行 0.354 秒,ProcessPoolExecutor(16) 用了 4.423 秒,慢 12.5 倍。同一台机器上直接起 16 个独立的 Python 进程各跑一份重活,单进程耗时 1.33 秒,16 个并行只要 1.54 秒,接近 13.8 倍——核是真的,进程池的开销也是真的。所以问题不在「多进程没用」,在「任务太小,多进程的成本盖过了收益」。

判断门槛我给一个经验值:单任务耗时低于 10 毫秒,别用进程池;10 到 100 毫秒之间,先量一次再决定;超过 100 毫秒,进程池的固定成本才开始被摊薄。日志场景是同一个坑的另一面:跨进程时 QueueListener 要换成 multiprocessing.Manager().Queue(-1),那篇 Python logging 复盘记的就是这一层。

线程帮不帮忙,取决于有没有释放 GIL

同样是「CPU 密集」,线程的效果可以差出一个数量级。三组对照,每组 16 份任务:

负载串行16 线程结论
纯 Python 循环 300 万次6.103 s7.425 s线程反而慢 21.7%
hashlib 每次 update 256 KB0.018 s0.007 s线程快 2.6 倍
hashlib 每次 update 1 KB0.020 s0.023 s无加速

差别在 2047 字节这条线上。hashlib 官方文档原话:「To allow multithreading, the Python GIL is released while computing a hash supplied more than 2047 bytes of data at once in its constructor or .update method.」一次喂进去的字节数超过 2047,C 层的计算就放在 GIL 之外,16 个线程能真的并行;每次只喂 1 KB,GIL 全程被攥着,线程只是在轮流等锁,还要额外付上下文切换的钱。

同一个道理可以推广到所有 C 扩展:zlib、lzma、numpy 的部分运算、sqlite3 的 C 层调用都属于「可能释放 GIL」这一类。「Python 有 GIL 所以线程没用」这句话是错的,正确的说法是「GIL 决定了哪些线程有用」。判断方法不是查文档,是量:同一份任务,串行跑一遍,线程跑一遍,差多少就是多少。

纯 Python 循环那组还顺带证明了一件事:16 个线程比串行慢 21.7%。这不是异常,是 GIL 争抢的代价——线程不停地在锁上排队、唤醒、切走,而这些动作本身要花时间。所以「多开线程总不会更差」是错觉。

队列真正的价值是背压,不是并发

很多人上 queue.Queue 是为了「并发」,但它真正的功能是限制在途任务数。5 万条任务、8 个消费者、每条 0.5 毫秒,两种写法:

写法入队耗时总墙钟峰值排队Python 堆峰值
Queue() 无界0.501 s7.261 s49,8821.91 MB
Queue(1000) 有界6.665 s6.801 s1,0000.04 MB
submit 无界提交 5 万次3.375 s9.970 s50,000 个 Future97.58 MB

三行读法:无界队列的「入队耗时」只有 0.5 秒,看着很爽,代价是 49,882 条任务同时压在内存里;有界队列的入队被阻塞到 6.665 秒,但那不是变慢,是生产者被迫等消费者,最后总墙钟反而少了 6.3%。第三个写法最危险:submit 永不阻塞,5 万个 Future 在内存里堆到 97.58 MB,总耗时还是三者里最长的 9.97 秒。

这就是背压。它不是性能优化,是「让生产速度服从消费速度」的唯一办法。队列的 maxsize 一旦写成 0 或不填,这个功能就等于关掉了,代码还能跑,只是内存峰值变成一个你控制不了的数字。至于队列放到进程之外以后的重试语义、可见性与锁,属另一层问题,huey、APScheduler 与 Celery 的七个静默失效那篇挖得更深。

正确的骨架长这样,注意 task_done() 在 finally 里:

import queue, threading

q = queue.Queue(maxsize=1000)
def worker():
    while True:
        item = q.get()
        if item is None:
            q.task_done()
            return
        try:
            handle(item)          # 单个任务,异常在内部处理
        finally:
            q.task_done()         # 必须执行,否则 join() 永不返回

threads = [threading.Thread(target=worker, daemon=True) for _ in range(8)]
for t in threads:
    t.start()
for item in source():             # 生产者:队列满时自然阻塞
    q.put(item)
q.join()                          # 等所有任务 task_done

四个默认值,全都不报错

这一节的四个默认值,本机实测确认,官方文档也都能查到,但没有任何一个会在你写错时提醒你:

最后一条最容易被忽略,因为 executor.map() 看起来「会等」——它确实会等,但等的是按顺序取结果:map 返回的迭代器严格按输入顺序产出,第一个任务慢,后面的结果全堵在后面。实测 10 个任务、耗时从 1.0 秒递减到 0.1 秒:map 拿到的第一个结果在 1.00 秒,as_completed 拿到的第一个结果在 0.10 秒。要做「谁先完成先处理」,只有 as_completed 这一个答案。

Troubleshooting:八个真实报错

下面每一条都是我在这次实验里实际撞到并复现的,报错文本原样复制,不是「典型报错」。

报错一:RuntimeError: cannot schedule new futures after shutdown

现象:退出阶段还有清理钩子往线程池里扔任务,直接抛这个错。原因:shutdown() 之后执行器已经关了,文档明确写「Calls to Executor.submit() and Executor.map() made after shutdown will raise RuntimeError」。修法:把「停止接收」和「排空」拆成两步,用一个布尔开关挡住新任务,或者把提交点包在 try/except RuntimeError 里并记账。

报错二:ValueError: task_done() called too many times

现象:消费循环里 task_done() 写在 try 外面,任务抛异常时又走了一遍 finally,计数被减了两次。原因:task_done() 和 put() 必须一一对应,文档写「Raises a ValueError if called more times than there were items placed in the queue」。修法:task_done() 只写在 finally 里一次,且 get() 与 task_done() 成对出现在同一个函数体里。

报错三:join() 永不返回,而且不报错

现象:q.join() 卡死,没有异常,没有日志。实测把「忘了 task_done()」的那份代码跑起来,2 秒后 join 所在线程仍然活着,unfinished_tasks 停在 1。原因:join() 等的是未完成计数归零,取走任务不等于完成。修法:诊断阶段先打 q.unfinished_tasks 定位,再把 task_done() 补进 finally;生产代码里别用裸 join(),前面套一个带超时的看门线程。

报错四:BrokenProcessPool: A process in the process pool was terminated abruptly while the future was running or pending.

现象:子进程里调了 os._exit()(或被杀),父进程在 map 上炸掉。原因:进程池发现 worker 非正常死亡就整体作废,不会自动重启。修法:子进程里别用 os._exit(),异常要抛回父进程;父进程要重建执行器,而不是复用。注意这个异常是 RuntimeError 的子类(实测 MRO 为 BrokenProcessPool → BrokenExecutor → RuntimeError),随手写的 except RuntimeError 会把它一起吞掉。

报错五:AttributeError: Can't get local object 'f5..local_work'

现象:把在函数内部定义的闭包丢给进程池,报这个。注意它不是我原先以为的「Can't pickle local object」,原文是 Can't get local object,按后者去搜会搜错方向。原因:spawn 启动的子进程只有一个空壳 __main__,取不到父进程里定义的局部对象。修法:被提交的函数必须是模块顶层可导入的名字,参数必须是可 pickle 的简单对象。

报错六:RuntimeError: An attempt has been made to start a new process before the current process has finished its bootstrapping phase.

现象:Windows 上忘了写 if __name__ == "__main__":,父进程抛这个;子进程 stderr 里还有一份它自己的 traceback。原因:spawn 会把主模块重新导入一遍,模块级代码在子进程里又执行了一次,于是子进程也开始建进程池。修法:所有入口代码放进 if __name__ == "__main__":,打包成 exe 的再加一行 freeze_support()。同一个错误我跑三次拿到两种结局:一次是父进程的 RuntimeError,另外两次是子进程先死、父进程拿到 BrokenProcessPool——按报错字符串搜问题会搜到两个不同的页面,根因是同一个。

报错七:RuntimeError: asyncio.run() cannot be called from a running event loop

现象:在协程里为了「跑一小段同步代码」调了 asyncio.run()。原因:一个线程只能有一个运行中的事件循环。修法:已经在线循环里就 await,要跑同步阻塞代码用 await asyncio.to_thread(fn)。附带一条容易漏看的:这个错还会带一句 RuntimeWarning: coroutine 'sleep' was never awaited,警告往往比异常更早出现在日志里。

报错八:协程里调 time.sleep(),不报错,只是并发归零

现象:20 个协程各睡 50 毫秒,期望 0.05 秒左右完成,实测 1.009 秒;把 time.sleep 换成 await asyncio.sleep 后是 0.068 秒,差 14.8 倍。原因:time.sleep 阻塞整个线程,事件循环停摆,20 个任务退化成串行。修法:协程里只调 await 版;第三方同步库一律用 asyncio.to_thread 包一层。这类「不报错」的坑比异常危险得多,因为它只表现为「慢」,不会出现在任何日志里。取消与超时的完整语义是另一组同源陷阱,asyncio 取消那篇记了六处同样不报错的失效。

什么时候确实该上队列:五问决策树

走到这里,答案可以做成一张流程:

第 5 条还有个补充判据,来自官方文档里一句容易被跳过的话:ThreadPoolExecutor「All threads enqueued to ThreadPoolExecutor will be joined before the interpreter can exit」,紧接着又写「it is recommended that ThreadPoolExecutor not be used for long-running tasks」。也就是说,解释器退出会等所有线程跑完,一个卡住的长任务会让整个进程退不出去。长任务要么放进程池,要么放队列,要么自己管好取消——这正是 2026 年 11 月 1 日那篇讲 asyncio 取消语义的文章要解决的问题,两篇可以对着看。队列本身的库级差异,那篇讲 huey、APScheduler 与 Celery 七个静默失效的实测也值得一起读。

本文的边界

一张可以直接抄的写法清单

# 1) I/O 密集:线程池,8 起手,按墙钟加
from concurrent.futures import ThreadPoolExecutor
with ThreadPoolExecutor(max_workers=8) as ex:
    for r in ex.map(fetch, urls):     # 顺序敏感就用 map
        save(r)

# 2) 谁先完成先处理:as_completed,不要用 map
from concurrent.futures import as_completed
futs = {ex.submit(fetch, u): u for u in urls}
for f in as_completed(futs):
    handle(futs[f], f.result())

# 3) CPU 密集且是纯 Python:进程池,任务粒度 > 100 ms
from concurrent.futures import ProcessPoolExecutor
def heavy(n): ...                      # 必须是模块顶层函数
with ProcessPoolExecutor() as ex:
    list(ex.map(heavy, payload, chunksize=8))   # chunksize 别用默认的 1

# 4) 生产快于消费:有界队列 + task_done 写在 finally
q = queue.Queue(maxsize=1000)

三句话总结这次实验:先量瓶颈,再选形态;默认值只是保护,不是最优;队列买的是「活过重启」和「背压」,不是速度。如果你想顺着这条线继续往下,10 月 29 日那篇 subprocess 复盘用了同一套方法,讲的是「退出码 0 但什么都没发生」。

👉 立即参与小米 MiMo 开放平台:国内领先的 AI 大模型开放平台,高性价比推理服务

👉 立即参与阿里云 AI:汇集爆款 AI 产品,热门模型专属权益优惠券助力企业创新加速

📌 本文由 AI 辅助生成并经人工审核发布 | TechPassive — AI 驱动的内容测试站点,专注于效率工具与 SaaS 真实评测

🔗 精选推荐工具

使用以下链接支持我们持续产出高质量内容(点击可直接前往购买):

作为亚马逊联盟会员,符合条件的购买会为我们带来佣金,不会增加你的购买成本。

☁️ DigitalOcean 云服务器 ⚡ Vultr 高性能 VPS 🤖 QoderWork 中国版(推荐有奖) ☁️ 阿里云爆款 AI 产品 📚 WordPress 实用书单 🧠 AI / 大模型书单 🏗️ 系统设计/云架构书单 🐳 Docker/K8s 书单 🐧 Linux 系统管理书单 🐍 Python 编程书单 🗄️ 数据库/PostgreSQL 书单 🚀 DevOps/SRE 书单 🤖 小米 MiMo 开放平台
← 返回首页