Python 并发编程：ThreadPoolExecutor vs ProcessPoolExecutor

在Python并发编程中，ThreadPoolExecutor和ProcessPoolExecutor是concurrent.futures模块提供的两种执行器，用于简化线程/进程池管理。以下是核心对比：

一、底层机制对比

二、适用场景

1. I/O密集型任务

   • 推荐 ThreadPoolExecutor
   • 例如：网络请求、文件读写、数据库操作
   • 优势：线程在I/O等待时释放GIL，轻量级切换
     $$ \text{效率} \propto \frac{1}{\text{I/O等待时间}} $$

2. CPU密集型任务

   • 推荐 ProcessPoolExecutor
   • 例如：数学计算、图像处理、加密解密
   • 优势：多进程并行利用多核CPU
     $$ \text{加速比} \approx \frac{T_{\text{单核}}}{T_{\text{多核}}/n} \quad (n=\text{核心数}) $$

三、性能差异演示

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
import time

# CPU密集型函数
def cpu_bound(n):
    return sum(i*i for i in range(n))

# I/O密集型函数
def io_bound(delay):
    time.sleep(delay)
    return delay

# 测试函数
def benchmark(executor, func, args):
    start = time.time()
    with executor(max_workers=4) as ex:
        results = list(ex.map(func, args))
    return time.time() - start

# 测试结果
cpu_args = [10_000_000] * 8
io_args = [0.1] * 20

print(f"CPU-bound ProcessPool: {benchmark(ProcessPoolExecutor, cpu_bound, cpu_args):.2f}s")
print(f"CPU-bound ThreadPool:  {benchmark(ThreadPoolExecutor, cpu_bound, cpu_args):.2f}s")
print(f"I/O-bound ThreadPool:  {benchmark(ThreadPoolExecutor, io_bound, io_args):.2f}s")
print(f"I/O-bound ProcessPool: {benchmark(ProcessPoolExecutor, io_bound, io_args):.2f}s")

典型输出：

CPU-bound ProcessPool: 3.21s  # 多核并行加速
CPU-bound ThreadPool:  12.87s # GIL导致伪并行
I/O-bound ThreadPool:  0.52s  # 高效切换
I/O-bound ProcessPool: 1.78s  # 进程创建开销

四、选择策略

1. 优先考虑任务类型
   • CPU密集型 → ProcessPoolExecutor
   • I/O密集型 → ThreadPoolExecutor
2. 注意数据传递成本
   • 进程间通信需pickle序列化，避免传递大型对象
3. 资源限制
   • 线程池：适合数百~数千轻量任务
   • 进程池：通常限制为CPU核心数

关键公式：
对于$n$个任务和$w$个工作线程/进程：
$$ \text{总耗时} = \max\left(\frac{n}{w} \times t_{\text{task}}, : t_{\text{overhead}}\right) $$
其中$t_{\text{overhead}}$包含线程切换/进程创建开销。