加线程后,Python 脚本为何时快时不快
GIL 只阻止 Python 代码并行执行;先测清程序是在等待还是在计算,再选线程、进程或 asyncio。
要点速览
- 线程和 asyncio 适合等待网络或磁盘的工作。纯 Python 计算要绕开 GIL,得用进程。
- NumPy 在许多底层操作中会释放 GIL,所以线程处理数值数据时能真正并行,dtype=object 数组除外。
- Python 3.13 起提供的自由线程构建会带来约 1% 到 8% 的额外开销,尚未适配的扩展还会重新启用 GIL。
客户发来一个 20 万行的交易文件。脚本要为每一行调用客户的 API 补充详细信息,规范化几个文本字段,再按分行计算汇总。试跑一次就花掉整个下午。你把循环套进 ThreadPoolExecutor 再跑:有时快了很多,有时几乎没变化。
这种忽快忽慢并非偶然。它说明你在弄清程序把时间花在哪里之前,就先选了工具。在客户现场,这个错误代价不小:演示时承诺了一个数字,事后才发现根本达不到。
正确的顺序恰好相反。先测程序是在等待还是在计算,再在线程、进程和 asyncio 之间做选择。每种方案都有局限,Python 官方文档写得很清楚。
GIL 只阻止一件事:并行执行 Python 代码
Python 的 threading 文档说得很直白:由于 GIL,同一时刻只有一个线程能执行 Python 字节码,因此线程对 CPU 密集型工作的性能帮助不大。这句话常被误读成“Python 里的线程没用”。
实际上,GIL 只阻止 Python 代码同时运行。同一份文档指出,线程特别适合 I/O 密集型任务,比如文件操作或网络调用,这类任务大部分时间都在等待外部资源。一个线程等 HTTP 响应时,另一个线程可以继续干活。
对 CPU 密集型任务,文档推荐 multiprocessing 或 ProcessPoolExecutor。按 multiprocessing 文档的说法,它用子进程代替线程,从而绕开 GIL。
对做数据的人来说,有一个重要的例外。NumPy 文档写道,NumPy 在许多底层操作中会释放 GIL,因此大部分时间都在这些底层代码里运行的线程能真正并行。但对 dtype=np.object_ 数组的操作不会释放 GIL。
两个时钟告诉你该怎么选
最简单的诊断方法是对比两个时钟。time.perf_counter() 测量实际流逝的时间(墙钟时间),包括程序休眠的时间。time.process_time() 只测 CPU 时间,不含休眠。
根据这两个定义,结果可以这样解读:两个数字接近,说明 CPU 几乎一直在工作;CPU 时间远小于墙钟时间,差值就是程序没占用 CPU 的时间,通常是在等网络或磁盘。
import time
def measure(label, fn, *args):
t0, c0 = time.perf_counter(), time.process_time()
result = fn(*args)
wall = time.perf_counter() - t0
cpu = time.process_time() - c0
print(f"{label}: 墙钟={wall:.1f}s CPU={cpu:.1f}s")
return result
这项测量必须在顺序执行的版本上做,也就是加线程或进程之前。原因是:process_time() 只统计被测进程自身的 CPU,交给子进程的工作不会计入;而多个线程一起计算时,它们的 CPU 时间会累加。这一步的目的,是在改动任何东西之前先给每个阶段归类。
用这个函数包住管道的每个阶段。假设得到这样的结果:API 调用阶段墙钟时间很长,CPU 时间接近零;用 regex 和 for 循环做规范化的阶段,墙钟时间和 CPU 时间大致相等;NumPy 汇总阶段也一样。这三个阶段需要三种不同的处理方式。
| 阶段 | 时间花在哪里 | 合适的工具 |
|---|---|---|
| 调用 API、读数据库、下载文件 | 等待网络或磁盘 | asyncio 或 ThreadPoolExecutor |
| 纯 Python 的循环、regex、dict | 在 Python 代码中计算,受 GIL 限制 | ProcessPoolExecutor |
| 对大型 NumPy 数组的运算 | 在已释放 GIL 的底层代码中计算 | 线程,或交给 NumPy 处理 |
实例:一条管道,三种工具
先从 API 调用阶段算起。假设每次调用耗时 200 ms,每行一次,正好 20 万次:顺序执行需要 40,000 秒,超过 11 小时。
如果客户的 API 能承受 20 个并发连接,理论上可以降到约 2,000 秒,因为这些时间几乎全是等待。
下一步最容易出错。你已经有了 asyncio 事件循环,很容易顺手在协程里直接调用规范化函数。asyncio 文档提醒:如果一个计算密集的函数运行 1 秒,其他所有 Task 和并发 I/O 操作都会被推迟 1 秒。
正确做法是通过 loop.run_in_executor 把计算推到进程池,让事件循环只负责等待。下面的代码是用来说明结构的示意:load_ids 需要你接到客户的真实文件上;在客户环境中运行前,还要补上重试、日志和错误处理。
import asyncio
from concurrent.futures import ProcessPoolExecutor
import httpx
API_URL = "https://api.example-customer.com" # 替换为客户的真实地址
CHUNK = 5000
def clean_row(row): # 示例:规范化分行名称
row["branch"] = row["branch"].strip().upper()
return row
def normalise(batch): # 模块级函数,可被 pickle
return [clean_row(r) for r in batch]
async def fetch(client, sem, rid):
async with sem: # 限制对客户 API 的压力
r = await client.get(f"/records/{rid}")
r.raise_for_status()
return r.json()
async def main(ids):
sem = asyncio.Semaphore(20)
loop = asyncio.get_running_loop()
pending = []
with ProcessPoolExecutor() as pool:
async with httpx.AsyncClient(base_url=API_URL, timeout=30) as client:
for i in range(0, len(ids), CHUNK): # 每次只有 5,000 个协程
chunk = ids[i:i + CHUNK]
rows = await asyncio.gather(*(fetch(client, sem, rid) for rid in chunk))
# 在进程池中规范化这一批,同时下一批继续调用 API
pending.append(loop.run_in_executor(pool, normalise, rows))
parts = await asyncio.gather(*pending)
return [row for part in parts for row in part]
if __name__ == "__main__":
ids = load_ids("transactions.csv") # 需自行实现:从客户文件中读取 20 万个 id
rows = asyncio.run(main(ids))
有三个细节值得注意。第一,normalise 和 clean_row 定义在模块级,而不是写成 lambda,因为 ProcessPoolExecutor 只能处理可 pickle 的对象,发出去的函数和返回的结果都一样。
第二,数据分成 40 批、每批 5,000 行发送,而不是逐行发送:pythonspeed.com 的 Itamar Turner-Trauring 指出,进程间传递数据可能非常慢,有时比计算本身还慢。
第三是分批循环:程序不会一次创建 20 万个协程,而是按每块 5,000 个 id 依次处理。这样内存可控;如果客户的 API 中途开始报错,你也知道停在哪一批。
最后一个阶段,数据已经变成数值数组,这时线程才派上用场。比如要按汇率换算金额,再按分行求和。数组乘法在 NumPy 的底层代码中执行,所以可以把数组切成几块,每块交给一个线程:
import numpy as np
from concurrent.futures import ThreadPoolExecutor
def convert(amounts, rates):
return amounts * rates # 数组运算,没有 Python for 循环
def convert_parallel(amounts, rates, n=4):
a_parts = np.array_split(amounts, n)
r_parts = np.array_split(rates, n)
with ThreadPoolExecutor(max_workers=n) as pool:
parts = list(pool.map(convert, a_parts, r_parts))
return np.concatenate(parts)
# amounts、rates、branch_ids:由上一步的 rows 构建的 NumPy 数组
converted = convert_parallel(amounts, rates)
totals = np.bincount(branch_ids, weights=converted)
只有 20 万行时,这部分不加线程可能就已经够快。数组大得多时,这个技巧才值得用。检验方法很简单:先测 convert 对整个数组跑一次的墙钟时间,再测 convert_parallel。如果数字没有下降,线程就没有带来收益,应该去掉。
反过来,如果你的“NumPy 运算”其实是对每个元素跑 for 循环,线程也帮不上忙。那个循环仍然是 Python 代码,仍然要持有 GIL。
下个项目可以试的五个步骤
- 在顺序执行版本上测量每个阶段的墙钟时间和 CPU 时间,改动之前先把结果记下来。
- 等待型阶段:客户端库支持异步就用 asyncio,否则用
ThreadPoolExecutor。一定要限制连接数,客户的系统不是为承受你的压测而设计的。 - 纯 Python 计算阶段:用
ProcessPoolExecutor,分批发送数据。 - NumPy 阶段:先确认代码确实是数组运算、数组不是
dtype=object,再尝试线程。 - 用第一步中完全相同的函数再测一次墙钟时间,把前后数字报告给客户。
这组前后对比的数字,也正是该写进简历的内容。比如“把 API 等待移到 asyncio、规范化移到进程池,将客户文件的处理时间从 X 降到 Y”,这样一行能让招聘方看到你会诊断问题,而不只是会加线程。
面试中如果聊到 GIL,这样的真实例子总比背下来的定义更有说服力。
反复出现的错误
最常见的错误,是把 lambda 或在 notebook 里随手写的函数传给进程池。ProcessPoolExecutor 只能处理可 pickle 的对象,稳妥的做法是把函数移到 .py 文件的模块级,再导入使用。
第二个错误,是不知不觉让计算混进了事件循环。在那里每计算一秒,其他所有 Task 就得干等一秒。asyncio 服务异常缓慢时,先在协程周围测一下 CPU 时间,再去怪网络。
第三个错误,是把进程和本身已经多线程的库混用。Polars 文档指出,Polars 自身就以多线程运行,而 fork 一个多线程进程可能导致死锁,因此它推荐在所有平台上使用 spawn,这是最安全的方式。
spawn 的代价是进程启动较慢。这也是应该只创建一次进程池、在多个批次间复用,而不是为每个小任务都启动新进程的又一个理由。
没有 GIL 的 Python 呢?
从 Python 3.13 起,CPython 提供了禁用 GIL 的自由线程构建。PEP 779 规定了第二阶段的标准:该构建获得官方支持,但仍是可选项;是否设为默认,留给之后的 PEP 决定。听起来很诱人,但目前还不该作为客户系统的首选。
Python 文档说明,自由线程构建会带来额外开销。在 pyperformance 基准测试套件上,平均开销从 macOS aarch64 上的约 1% 到 Linux x86-64 上的 8% 不等。
更危险的是,一些带有尚未适配的扩展模块的第三方包会把 GIL 重新打开。
如果想尝试,先列出客户环境中所有带扩展的库,逐一检查。然后用上面那两个时钟再测一遍。工具会变,但第一个问题始终不变:你的程序是在等待,还是在计算?
这篇文章对你有帮助吗?
感谢你的反馈!
10 个信源
- threading — Thread-based parallelism — Python documentation
- multiprocessing — Process-based parallelism — Python documentation
- Developing with asyncio — Python documentation
- concurrent.futures — Launching parallel tasks — Python documentation
- Python support for free threading — Python documentation
- PEP 779 – Criteria for supported status for free-threaded Python
- Thread Safety — NumPy Manual
- time — Time access and conversions — Python documentation
- Python's multiprocessing performance problem (Itamar Turner-Trauring, pythonspeed.com)
- Multiprocessing — Polars user guide