FDE Times 数据在招 FDE 职位 882▼2 近 7 天在招职位数的变化(同口径比较):不计入本周新开始追踪的公司的职位近 7 天新增 52在招公司 185支持远程 25%美国薪资中位数 $200k招聘最多 Databricks 98
ENVI

前线部署工程师(FDE)的专业媒体

技能指南 · 指南

加线程后,Python 脚本为何时快时不快

GIL 只阻止 Python 代码并行执行;先测清程序是在等待还是在计算,再选线程、进程或 asyncio。

分享微博

要点速览

  • 线程和 asyncio 适合等待网络或磁盘的工作。纯 Python 计算要绕开 GIL,得用进程。
  • NumPy 在许多底层操作中会释放 GIL,所以线程处理数值数据时能真正并行,dtype=object 数组除外。
  • Python 3.13 起提供的自由线程构建会带来约 1% 到 8% 的额外开销,尚未适配的扩展还会重新启用 GIL。
决策树:对比墙钟时间和 CPU 时间。CPU 时间远小于墙钟时间,说明程序在等待,用 asyncio 或 ThreadPoolExecutor;CPU 时间与墙钟时间大致相等,说明程序在计算:纯 Python 代码用 ProcessPoolExecutor,NumPy 运算用线程,dtype=object 数组除外。
先测量,再选工具:等待网络或磁盘的时间用 asyncio 或线程,纯 Python 计算用进程池,会释放 GIL 的 NumPy 运算用线程。来源:Python 官方文档(threading、multiprocessing、asyncio、time)和 NumPy 文档。

客户发来一个 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。

下个项目可以试的五个步骤

  1. 在顺序执行版本上测量每个阶段的墙钟时间和 CPU 时间,改动之前先把结果记下来。
  2. 等待型阶段:客户端库支持异步就用 asyncio,否则用 ThreadPoolExecutor。一定要限制连接数,客户的系统不是为承受你的压测而设计的。
  3. 纯 Python 计算阶段:用 ProcessPoolExecutor,分批发送数据。
  4. NumPy 阶段:先确认代码确实是数组运算、数组不是 dtype=object,再尝试线程。
  5. 用第一步中完全相同的函数再测一次墙钟时间,把前后数字报告给客户。

这组前后对比的数字,也正是该写进简历的内容。比如“把 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 个信源
路线图上的下一篇 · 阶段 2: 全栈工程能力百行脚本把客户的 OpenAPI 文件变成 Agent 工具草稿脚本解析 $ref,同时输出 Claude 与 OpenAI 格式;挑端点、写描述仍归前线部署工程师(FDE)。