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

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

原文: https://fdetimes.net/zh/guides/python-threads-processes-asyncio-data/

客户发来一个 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 的时间，通常是在等网络或磁盘。

```python
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` 需要你接到客户的真实文件上；在客户环境中运行前，还要补上重试、日志和错误处理。

```python
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 的底层代码中执行，所以可以把数组切成几块，每块交给一个线程：

```python
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 重新打开。

如果想尝试，先列出客户环境中所有带扩展的库，逐一检查。然后用上面那两个时钟再测一遍。工具会变，但第一个问题始终不变：你的程序是在等待，还是在计算？

**本周动手试试:**

- 找一个慢的数据处理脚本，在每个阶段前后打印 time.perf_counter() 和 time.process_time()，看哪些部分在等待、哪些在计算。
- 检查管道中的 NumPy 数组，找出 dtype=object 的那些：线程在那里帮不上忙。
- 在 ProcessPoolExecutor 中，把一段使用 lambda 的代码改写成模块级函数，分批发送数据，再测量改动前后的时间。

## 信源

- [threading — Thread-based parallelism — Python documentation](https://docs.python.org/3/library/threading.html)

- [multiprocessing — Process-based parallelism — Python documentation](https://docs.python.org/3/library/multiprocessing.html)

- [Developing with asyncio — Python documentation](https://docs.python.org/3/library/asyncio-dev.html)

- [concurrent.futures — Launching parallel tasks — Python documentation](https://docs.python.org/3/library/concurrent.futures.html)

- [Python support for free threading — Python documentation](https://docs.python.org/3/howto/free-threading-python.html)

- [PEP 779 – Criteria for supported status for free-threaded Python](https://peps.python.org/pep-0779/)

- [Thread Safety — NumPy Manual](https://numpy.org/doc/stable/reference/thread_safety.html)

- [time — Time access and conversions — Python documentation](https://docs.python.org/3/library/time.html)

- [Python's multiprocessing performance problem (Itamar Turner-Trauring, pythonspeed.com)](https://pythonspeed.com/articles/faster-multiprocessing-pickle/)

- [Multiprocessing — Polars user guide](https://docs.pola.rs/user-guide/misc/multiprocessing/)
