一、基础知识

先区分两个词:并发是"一段时间内处理多个任务",任务可能交替执行;并行是"同一时刻真的有多个任务在跑",需要多核 CPU 支持。

Python 里三种主流并发工具:

  • threading(线程):同一个进程内的多个执行流,共享内存。适合 I/O 密集型任务,比如网络请求、读写文件——这些操作大部分时间在等待,等的时候可以切换去做别的。
  • multiprocessing(进程):每个进程有独立的内存空间和 Python 解释器,能真正利用多核。适合 CPU 密集型任务,比如大量计算、图像处理。
  • asyncio(协程):单线程内的协作式并发,靠 await 在等待点主动让出控制权。适合大量高并发的 I/O 操作,比如同时处理成千上万个连接。

为什么 CPU 密集型不能用线程?因为 CPython 有一个全局解释器锁 GIL:同一时刻只有一个线程能执行 Python 字节码。所以多线程在 CPU 计算上几乎无法加速,反而因切换有额外开销。I/O 等待时线程会释放 GIL,这时多线程才有用。

一句话判断:等得多用线程或协程,算得多用进程。

二、实操步骤

下面三个例子都能直接运行,用 time.sleep 和简单计算模拟等待与计算,避免引入第三方依赖。

第 1 步:threading 处理 I/O 密集型任务

import threading
import time

def download(name):
    print(f"{name} 开始")
    time.sleep(1)          # 模拟网络等待,期间会释放 GIL
    print(f"{name} 完成")

start = time.perf_counter()
threads = []
for i in range(5):
    t = threading.Thread(target=download, args=(f"任务{i}",))
    t.start()
    threads.append(t)
for t in threads:
    t.join()               # 等待所有线程结束
print("总耗时", round(time.perf_counter() - start, 2), "秒")

串行执行需要约 5 秒,5 个线程并发只需约 1 秒。join() 不能漏,否则主线程退出时子线程可能被强制结束。

第 2 步:multiprocessing 处理 CPU 密集型任务

import multiprocessing
import time

def cpu_work(n):
    total = 0
    for i in range(n):
        total += i * i
    return total

if __name__ == "__main__":   # Windows 下必须写这行保护
    start = time.perf_counter()
    with multiprocessing.Pool() as pool:
        results = pool.map(cpu_work, [5_000_000] * 4)
    print("结果数量", len(results))
    print("总耗时", round(time.perf_counter() - start, 2), "秒")

Pool 会自动按 CPU 核数分配任务。if __name__ == "__main__" 在 Windows 上必不可少,否则会无限生成子进程。

第 3 步:asyncio 处理大量 I/O 等待

import asyncio
import time

async def fetch(name):
    print(f"{name} 开始")
    await asyncio.sleep(1)   # 异步等待,让出控制权
    print(f"{name} 完成")
    return name

async def main():
    start = time.perf_counter()
    tasks = [asyncio.create_task(fetch(f"任务{i}")) for i in range(5)]
    results = await asyncio.gather(*tasks)
    print("完成数量", len(results))
    print("总耗时", round(time.perf_counter() - start, 2), "秒")

asyncio.run(main())

注意 await 后面必须是可等待对象,且协程内不能调用阻塞函数(比如 time.sleep),否则整个事件循环会被卡住。

第 4 步:按任务类型选择

任务类型 例子 首选方案
I/O 密集、数量少 几个 HTTP 请求 threading
I/O 密集、数量极大 大量并发连接 asyncio
CPU 密集 数值计算、加密 multiprocessing
既要计算又要 I/O 抓数据后分析 进程 + 线程/协程组合

三、关键细节

  1. GIL 只影响 CPU 密集型:I/O 等待时线程会释放 GIL,所以网络请求、文件读写用线程依然能加速,不要一概否定多线程。
  2. 线程共享内存,必须加锁保护共享数据:多个线程同时改一个计数器会出错,用 threading.Lock 保护临界区。
  3. 进程之间内存隔离,通信要靠机制:用 multiprocessing.Queue 或 Pipe 传数据,直接改全局变量不会影响其他进程。
  4. asyncio 里不能混入阻塞调用:一个 time.sleep 或同步的 requests.get 会卡住整个事件循环,应改用 asyncio.sleep 和异步 HTTP 库。
  5. 线程/进程数量不是越多越好:远超 CPU 核数或 I/O 承受能力时,切换和调度开销反而让性能下降。
  6. if __name__ == "__main__" 保护:尤其在 Windows 上使用 multiprocessing 时,缺少它会导致子进程反复创建。

四、常见错误

现象 原因 修正
多线程做数值计算,速度几乎没提升甚至更慢 GIL 限制同一时刻只有一个线程执行字节码 改用 multiprocessing
Windows 上运行多进程脚本无限创建子进程 没有 if __name__ == "__main__" 保护 把创建进程的代码放进该保护块
主线程退出了,子线程还没做完 没有调用 join() 等待 收集线程后逐个 join()
asyncio 程序"卡住",并发效果为零 在协程里用了 time.sleep 等阻塞函数 换成 await asyncio.sleep 等异步版本
多线程累加计数器结果小于预期 多个线程同时读写共享变量,操作不是原子的 用 threading.Lock 包住修改操作
用 asyncio.run() 时报错"已在运行的事件循环中" 在已有循环里再次调用 run 嵌套场景改用 await,不要重复 run

五、排查方法

  1. 先判断任务类型:把耗时点打印出来,看时间花在"等待"还是"计算",这是选型的第一步。
  2. 用 time.perf_counter() 分别测串行与并发耗时,确认是否真的变快,而不是凭感觉。
  3. 检查阻塞点:在 asyncio 程序中逐个替换可疑的同步调用为异步版本,观察是否恢复并发。
  4. 检查共享数据:出现结果不一致时,给共享变量的读写加锁后再测。
  5. 用任务管理器或 top 观察 CPU 占用:CPU 密集任务应能看到多核利用,否则可能仍被 GIL 限制。
  6. 逐步增加并发数量,画出耗时曲线,找到性能拐点,避免盲目加线程。

六、注意事项

  • GIL 是 CPython 的实现细节,不同解释器实现可能不同;本文结论以 CPython 为准,其他实现请以官方文档为准。
  • 线程、进程、协程可以组合使用,比如进程池负责计算、协程负责网络 I/O,但组合越多调试越复杂,先简单后优化。
  • 多进程启动有成本,任务很轻量时进程反而更慢,不要一看到"并发"就上进程池。
  • asyncio 的生态依赖异步版库,同步库不能直接在协程里用,选型前先确认依赖是否支持异步。
  • 并发会放大资源消耗,注意连接池大小、文件句柄数等限制,避免把下游服务打满。

免责声明:本文为个人学习与实操经验总结,仅代表个人观点,不构成任何技术或商业决策建议。不同系统环境与版本可能存在差异,实际操作请以官方文档为准并自行验证。