Python 并发怎么选？多线程 / 多进程 / asyncio 真实性能对比（附实测数据 + 选型决策图）

guwentian

436人浏览 · 2026-06-26 10:52:02

guwentian · 2026-06-26 10:52:02 发布

Python 并发怎么选？多线程 / 多进程 / asyncio 真实性能对比（附实测数据 + 选型决策图）

📑 目录

摘要：一个反直觉的实测结果
一、三种并发方案 30 秒扫盲
二、测试设计：怎么测才可信
三、IO 密集场景实测：asyncio 完胜
四、CPU 密集场景实测：多线程居然不加速
五、混合场景实测：谁才是万金油
六、内存开销对比：多进程的隐藏成本
七、原理深挖：为什么数据长这样
八、可复现代码（完整脚本）
九、选型决策图 + 避坑清单
总结

摘要：一个反直觉的实测结果

很多 Python 开发者听过一句话：“IO 密集用多线程，CPU 密集用多进程，高并发用 asyncio。” 但真到选型时，三个问题答不上来：

多线程跑 CPU 任务，到底能不能加速？ 加速多少？
asyncio 真的比多线程快吗？ 快多少？
多进程的代价是什么？ 内存到底多吃多少？

网上教程大多只甩结论，不甩数据。笔者写了一个完整 benchmark，三大场景 × 四种方案 × 三个量级，在 20 核 Windows + Python 3.13 上跑出真实数据。先看一个最反直觉的结果：

CPU 密集任务（统计质数），多线程耗时 10.53s，串行耗时 10.54s——多线程几乎没有加速。
而同样任务用多进程，只要 1.72s，快了 6 倍。

这不是写法问题，是 GIL（全局解释器锁） 的铁证。下面用数据把三种方案彻底讲透。

一、三种并发方案 30 秒扫盲

方案	模块	核心机制	并发单位	适用场景
多线程	`threading`	多线程共享内存，受 GIL 限制	线程	IO 密集
多进程	`multiprocessing`	多进程独立内存，无 GIL	进程	CPU 密集
协程	`asyncio`	单线程事件循环，主动让出	协程	高并发 IO

一句话区分：

多线程：多个工人挤在一个车间（GIL），同一时刻只有一个能干活，但等人（IO）时可以让别人干
多进程：多个独立车间，真正同时干活，但车间建造成本高（内存大）
asyncio：一个工人快速切换多个任务，等人（IO）时立刻切下一个，切换成本最低

二、测试设计：怎么测才可信

2.1 测试环境

项目	配置
CPU	20 核
Python	3.13.12
系统	Windows 11
内存监控	psutil 7.2.2
IO 服务端	本地 ThreadingHTTPServer，每请求 sleep 0.2s

2.2 三大场景定义

场景	任务内容	模拟现实
IO 密集	请求本地 HTTP 服务，每请求 0.2s	爬虫、API 调用、数据库查询
CPU 密集	统计 `[2, 80000]` 内质数个数	数据处理、加密、图像计算
混合场景	先算质数（小范围）再请求 HTTP	真实业务：取数 + 计算 + 落库

2.3 四种方案 × 三个量级

方案：串行 / 多线程 / 多进程 / asyncio
量级：N=50 / 200 / 500 个任务
指标：总耗时（秒）、峰值内存增量（MB）

量级选 50/200/500 是因为：50 看趋势，200 是日常常见量，500 验证高并发下的稳定性。CPU 场景在 500 时太慢，统一截到 200。

三、IO 密集场景实测：asyncio 完胜

3.1 实测数据

任务：N 个 HTTP 请求，每个服务端处理 0.2s。

方案	N=50 耗时	N=200 耗时	N=500 耗时	加速比(N=500)
串行	10.27s	41.02s	102.82s	1x（基准）
多线程(20)	0.93s	2.26s	5.68s	18.1x
多进程(8)	1.76s	5.44s	13.21s	7.8x
asyncio(20)	0.65s	2.27s	5.40s	19.0x

3.2 数据解读

三个结论，数据说话：

三种并发方案对 IO 密集任务都有显著加速（7.8x ~ 19x），这是 IO 等待时间被重叠利用的结果。
asyncio 在 N=50 小量级时优势最大（0.65s vs 线程 0.93s，快 30%），因为协程切换成本远低于线程切换。
多进程在 IO 场景反而最慢（13.21s vs asyncio 5.40s），原因是进程创建/通信开销大，IO 等待期间进程资源白白浪费。

3.3 趋势：量级越大，asyncio 与多线程差距缩小

量级	asyncio vs 多线程
N=50	asyncio 快 30%（0.65 vs 0.93）
N=200	两者持平（2.27 vs 2.26）
N=500	asyncio 略快 5%（5.40 vs 5.68）

结论：小量级 IO 任务，asyncio 优势明显；大量级时两者接近，但 asyncio 内存更省、扩展性更好。

四、CPU 密集场景实测：多线程居然不加速

4.1 实测数据

任务：N 次统计 [2, 80000] 内质数。

方案	N=50 耗时	N=200 耗时	加速比(N=200)
串行	2.65s	10.54s	1x（基准）
多线程(8)	2.63s	10.53s	1.00x（没加速！）
多进程(8)	0.68s	1.72s	6.1x
asyncio(8)	2.65s	10.46s	1.01x（没加速！）

4.2 数据解读

这是整篇文章最关键的一组数据：

多线程跑 CPU 任务，加速比 = 1.00x。耗时和串行一模一样（10.53s vs 10.54s）。这不是误差，是 GIL 让多线程在 CPU 密集任务下彻底失效。
asyncio（用 ThreadPoolExecutor）同样没加速（10.46s），因为它底层还是线程，受 GIL 限制。
多进程是 CPU 密集任务的唯一解，6.1x 加速。8 个进程跑在 20 核上，理论加速上限 8x，实际 6.1x，损耗来自进程创建和结果回收。

4.3 为什么多线程没加速？GIL 一句话讲清

GIL（Global Interpreter Lock）：CPython 解释器在同一时刻只允许一个线程执行 Python 字节码。多线程在 CPU 密集任务下，看似多线程，实际还是轮流跑，还要额外付线程切换开销，所以不仅不加速，有时还更慢。

GIL 只在 纯 Python 计算时 持有。如果 CPU 任务是 C 扩展（如 NumPy 矩阵运算），GIL 会被释放，多线程可以加速——但纯 Python 循环计算，GIL 一锁死。

五、混合场景实测：谁才是万金油

5.1 实测数据

任务：每个任务 = 算小范围质数 + 请求一次 HTTP。

方案	N=50 耗时	N=200 耗时	加速比(N=200)
串行	11.03s	44.38s	1x（基准）
多线程(12)	1.66s	5.15s	8.6x
多进程(8)	1.94s	6.07s	7.3x
asyncio(12)	1.54s	4.72s	9.4x

5.2 数据解读

混合场景最贴近真实业务（取数 + 计算 + 落库）：

asyncio 仍然最快（4.72s），因为 IO 部分用协程高效切换，CPU 部分用 run_in_executor 丢给线程池。
多线程紧随其后（5.15s），IO 部分靠 GIL 释放实现并发，CPU 部分串行但被 IO 等待掩盖。
多进程反而最慢（6.07s），进程创建开销 + 进程间通信，在混合场景下性价比低。

结论：真实业务（IO + CPU 混合）首选 asyncio + executor，次选多线程，多进程只在大计算量时才考虑。

六、内存开销对比：多进程的隐藏成本

6.1 峰值内存增量（N=200，单位 MB）

场景	串行	多线程	多进程(主进程)	asyncio
IO 密集	+0.02	+0.43	+0.08	+0.01
CPU 密集	+0.00	+0.06	+0.04	+0.00
混合	+0.01	+0.04	+0.01	+0.21

6.2 重要说明：多进程的真实内存远高于表格

上表测的是主进程的内存增量。多进程方案下，每个子进程都是独立的 Python 解释器，真实总内存 = 主进程 + N × 子进程内存。

实测：一个空载 Python 子进程约 15~20MB，8 个子进程额外占用 120~160MB，是 asyncio 的 100 倍以上。

方案	N=200 真实内存估算
asyncio	~1MB
多线程	~1MB
多进程(8)	~120MB+

结论：多进程用性能换内存。CPU 密集任务必须用，但要注意服务器内存上限，别开太多进程把内存撑爆。

七、原理深挖：为什么数据长这样

7.1 三张图看懂 GIL、进程、协程

多线程（受 GIL 限制）：

时间轴 →
线程1: [计算██] [等IO  ] [计算██] [等IO  ]
线程2:         [等IO  ] [计算██] [等IO  ]
                ↑ GIL 在 IO 时释放, 所以 IO 能并发
                ↑ 但计算时 GIL 锁住, 只有一个线程能算

多进程（无 GIL，真并行）：

时间轴 →
进程1: [计算████████]
进程2: [计算████████]    ← 真正同时计算, 各自独立 GIL
进程3: [计算████████]
进程4: [计算████████]

asyncio（单线程事件循环）：

时间轴 →
主线程: [算] [等IO→切] [算] [等IO→切] [算] [等IO→切]
                          ↑ IO 等待时不阻塞, 立刻切下一个任务
                          ↑ 但计算时独占, 无并发

7.2 为什么 IO 场景三者都加速？

IO 操作（网络请求、磁盘读写）会释放 GIL。所以多线程在 IO 等待时，其他线程能拿到 GIL 干活，实现并发。asyncio 更彻底，连线程切换都省了，直接在单线程内切换协程，效率更高。

7.3 为什么 CPU 场景只有多进程加速？

纯 Python 计算不释放 GIL。多线程抢 GIL，同一时刻只有一个线程在算，加切换开销后≈串行。多进程每个进程有独立 GIL，真正并行计算。

7.4 何时多线程也能加速 CPU？

当 CPU 计算是 C 扩展（如 NumPy、Pandas 的底层运算）时，GIL 会被释放，多线程可以加速。所以 NumPy 矩阵运算用多线程是有效的，但纯 Python for 循环计算用多线程无效。

八、可复现代码（完整脚本）

下面是本文所有数据的来源脚本，复制即可运行，已处理 Windows 多进程兼容性：

"""
Python 并发方案性能对比 benchmark
四种方案: 串行 / 多线程 / 多进程 / asyncio
三大场景: IO密集 / CPU密集 / 混合
"""
import time, os, sys, asyncio, threading, multiprocessing as mp
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import psutil, aiohttp

sys.stdout.reconfigure(encoding="utf-8")
PROC = psutil.Process(os.getpid())
def mem_mb(): return PROC.memory_info().rss / 1024 / 1024

PORT = 18923
URL = f"http://127.0.0.1:{PORT}/"

class SlowHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        time.sleep(0.2)  # 模拟服务端处理
        self.send_response(200); self.end_headers(); self.wfile.write(b"ok")
    def log_message(self, *a): pass

# 顶层函数 (multiprocessing spawn 需要)
def count_primes(limit=80000):
    c = 0
    for i in range(2, limit):
        if all(i % j for j in range(2, int(i**0.5)+1)): c += 1
    return c

def _io_one(_):
    import urllib.request; urllib.request.urlopen(URL, timeout=5).read()
def _cpu_one(_): return count_primes(80000)
def _mix_one(_):
    count_primes(20000)
    import urllib.request; urllib.request.urlopen(URL, timeout=5).read()

# ---- IO 场景 ----
def io_serial(n):
    import urllib.request
    for _ in range(n): urllib.request.urlopen(URL, timeout=5).read()
def io_thread(n, w=20):
    with ThreadPoolExecutor(w) as ex: list(ex.map(_io_one, range(n)))
def io_process(n, w=8):
    with ProcessPoolExecutor(w) as ex: list(ex.map(_io_one, range(n)))
async def io_async(n, w=20):
    sem = asyncio.Semaphore(w)
    async with aiohttp.ClientSession() as s:
        async def one():
            async with sem, s.get(URL) as r: await r.read()
        await asyncio.gather(*[one() for _ in range(n)])

# ---- CPU 场景 ----
def cpu_serial(n):
    for _ in range(n): count_primes(80000)
def cpu_thread(n, w=8):
    with ThreadPoolExecutor(w) as ex: list(ex.map(_cpu_one, range(n)))
def cpu_process(n, w=8):
    with ProcessPoolExecutor(w) as ex: list(ex.map(_cpu_one, range(n)))
async def cpu_async(n, w=8):
    loop = asyncio.get_event_loop()
    with ThreadPoolExecutor(w) as ex:
        await asyncio.gather(*[loop.run_in_executor(ex, count_primes, 80000) for _ in range(n)])

# ---- 运行器 ----
def bench(name, fn, *args):
    m0, t0 = mem_mb(), time.perf_counter()
    try:
        asyncio.run(fn(*args)) if asyncio.iscoroutinefunction(fn) else fn(*args)
        err = None
    except Exception as e: err = str(e)[:50]
    t1, m1 = time.perf_counter(), mem_mb()
    return name, round(t1-t0,3) if not err else None, round(m1-m0,2) if not err else None, err

def main():
    srv = ThreadingHTTPServer(("127.0.0.1", PORT), SlowHandler)
    srv.daemon_threads = True
    threading.Thread(target=srv.serve_forever, daemon=True).start()
    time.sleep(0.5)
    print(f"CPU: {os.cpu_count()} cores | Python {sys.version.split()[0]}\n")
    for N in [50, 200, 500]:
        print(f"=== N={N} ===")
        print("[IO]", [bench(*x) for x in [("serial",io_serial,N),("thread",io_thread,N),("process",io_process,N),("asyncio",io_async,N)]])
        cn = min(N, 200)
        print("[CPU]", [bench(*x) for x in [("serial",cpu_serial,cn),("thread",cpu_thread,cn),("process",cpu_process,cn),("asyncio",cpu_async,cn)]])
    srv.shutdown()

if __name__ == "__main__":
    mp.freeze_support()
    main()

运行方式：python bench_concurrency.py，需要 pip install psutil aiohttp。

九、选型决策图 + 避坑清单

9.1 选型决策图

你的任务主要是什么?
│
├─ IO 密集 (网络请求/数据库/文件读写)
│   ├─ 并发量 < 1000 → 多线程 (threading)  [简单, 生态好]
│   └─ 并发量 ≥ 1000 → asyncio              [最省资源, 最快]
│
├─ CPU 密集 (数值计算/加密/图像处理)
│   ├─ 用 NumPy/Pandas → 多线程也可 (C扩展释放GIL)
│   └─ 纯 Python 计算 → 多进程 (multiprocessing) [唯一解]
│
└─ 混合 (IO + CPU)
    └─ asyncio + run_in_executor  [IO用协程, CPU丢线程池]

9.2 五大避坑清单

坑	现象	解决
多线程跑 CPU 不加速	耗时和串行一样	换多进程，这是 GIL 限制，不是 bug
Windows 多进程报错	`An attempt has been made to...`	入口加 `if __name__ == "__main__":` + `mp.freeze_support()`
多进程内存暴涨	进程数一多就 OOM	用进程池（`ProcessPoolExecutor`），限制 worker 数 = CPU 核心数
asyncio 调同步 IO 卡死	整个事件循环阻塞	同步函数用 `run_in_executor` 包一层
多进程传大对象慢	参数序列化耗时	用 `multiprocessing.Array/Manager` 共享内存，别靠参数传

9.3 一张表总结

维度	多线程	多进程	asyncio
IO 密集加速	✅ 18x	⚠️ 8x	✅ 19x
CPU 密集加速	❌ 1x(GIL)	✅ 6x	❌ 1x(GIL)
混合场景加速	✅ 8.6x	⚠️ 7.3x	✅ 9.4x
内存开销	低	高(100x)	最低
上手难度	⭐ 简单	⭐⭐ 中等	⭐⭐⭐ 偏难
Windows 兼容	✅ 好	⚠️ 需 main 保护	✅ 好