Python 多线程与多进程性能对比

news/2025/9/27 10:12:15/文章来源:href="https://blog.51cto.com/u_17353607/14132009" target="_blank"

在 Python 中处理并发任务时，多线程和多进程是两种常用方案。但很多开发者不清楚两者的适用场景，常因选错方案导致性能不升反降。其实 Python 的 GIL（全局解释器锁）特性，让多线程和多进程在性能表现上有显著差异。本文通过实际测试对比两者的性能表现，分析各自的适用场景，帮助你在实际开发中做出正确选择。

一、GIL 对多线程的影响

理解 GIL 是掌握 Python 并发编程的关键。GIL 是 Python 解释器的一种互斥锁，确保同一时刻只有一个线程执行 Python 字节码。这意味着，即使在多核 CPU 上，多线程也无法真正实现并行执行。

GIL 对不同类型任务的影响：

CPU 密集型任务：多线程由于 GIL 限制，无法利用多核优势，甚至可能因线程切换开销导致性能下降
I/O 密集型任务：线程在等待 I/O 操作（如网络请求、文件读写）时会释放 GIL，多线程能提升效率

二、性能对比实验

我们通过两组实验对比多线程和多进程的性能：CPU 密集型任务（计算质数）和 I/O 密集型任务（网络请求）。

1. CPU 密集型任务测试

import time
import threading
import multiprocessing# 计算指定范围内的质数（CPU密集型）
def count_primes(start, end):count = 0for num in range(start, end):if all(num % i != 0 for i in range(2, int(num**0.5) + 1)):count += 1return count# 单线程执行
def single_thread():start = time.time()count_primes(2, 10**6)return time.time() - start# 多线程执行
def multi_thread(num_threads=4):start = time.time()step = 10**6 // num_threadsthreads = []for i in range(num_threads):t = threading.Thread(target=count_primes,args=(2 + i * step, 2 + (i + 1) * step))threads.append(t)t.start()for t in threads:t.join()return time.time() - start# 多进程执行
def multi_process(num_processes=4):start = time.time()step = 10**6 // num_processesprocesses = []for i in range(num_processes):p = multiprocessing.Process(target=count_primes,args=(2 + i * step, 2 + (i + 1) * step))processes.append(p)p.start()for p in processes:p.join()return time.time() - startif __name__ == "__main__":# 测试并打印结果st = single_thread()mt = multi_thread()mp = multi_process()print(f"单线程: {st:.2f}秒")print(f"4线程: {mt:.2f}秒")print(f"4进程: {mp:.2f}秒")

测试结果（4核CPU）：

单线程: 28.63秒
4线程: 29.15秒  # 比单线程略慢，线程切换有开销
4进程: 7.82秒   # 接近线性提速，充分利用多核

结论：CPU 密集型任务中，多进程性能远优于多线程，线程数增加甚至会因切换开销导致性能下降。

2. I/O 密集型任务测试

import time
import threading
import multiprocessing
import requests# 网络请求任务（I/O密集型）
def fetch_url(url):try:response = requests.get(url, timeout=5)return response.status_codeexcept:return -1# 单线程执行
def single_thread_io():start = time.time()urls = ["https://www.baidu.com"] * 20for url in urls:fetch_url(url)return time.time() - start# 多线程执行
def multi_thread_io(num_threads=4):start = time.time()urls = ["https://www.baidu.com"] * 20threads = []def worker():while urls:url = urls.pop()fetch_url(url)for _ in range(num_threads):t = threading.Thread(target=worker)threads.append(t)t.start()for t in threads:t.join()return time.time() - start# 多进程执行
def multi_process_io(num_processes=4):start = time.time()urls = ["https://www.baidu.com"] * 20processes = []def worker():while urls:url = urls.pop()fetch_url(url)for _ in range(num_processes):p = multiprocessing.Process(target=worker)processes.append(p)p.start()for p in processes:p.join()return time.time() - startif __name__ == "__main__":st = single_thread_io()mt = multi_thread_io()mp = multi_process_io()print(f"单线程I/O: {st:.2f}秒")print(f"4线程I/O: {mt:.2f}秒")print(f"4进程I/O: {mp:.2f}秒")

测试结果：

单线程I/O: 12.45秒
4线程I/O: 3.28秒   # 性能提升明显
4进程I/O: 3.52秒   # 与多线程接近，略差

结论：I/O 密集型任务中，多线程和多进程性能接近，多线程因开销小略占优势。

三、线程与进程的核心差异

特性	多线程	多进程
内存共享	共享同一进程内存空间	各进程有独立内存空间
通信成本	低（通过全局变量）	高（需用队列/管道）
开销	小（线程创建销毁快）	大（进程创建销毁耗资源）
GIL 影响	受GIL限制	不受GIL限制
容错性	一线程崩溃可能导致整个进程崩溃	一进程崩溃不影响其他进程

通信方式对比

多线程通过全局变量通信：

# 多线程通信（简单）
shared_data = []
lock = threading.Lock()def thread_worker():with lock:  # 加锁避免竞争shared_data.append("数据")

多进程通过队列通信：

# 多进程通信（复杂）
from multiprocessing import Queueq = Queue()def process_worker():q.put("数据")  # 放入队列# 主进程从队列获取数据
data = q.get()

四、适用场景总结

优先用多线程的场景：

网络请求、文件读写等 I/O 密集型任务
任务间需要频繁通信
资源受限，无法创建大量进程

优先用多进程的场景：

数学计算、数据处理等 CPU 密集型任务
任务间独立性高，通信少
需要利用多核 CPU 性能
任务可能崩溃，需隔离故障

混合使用场景：

复杂系统可结合两者优势，如 "多进程+每进程多线程"
例：Web服务器通常用多进程利用多核，每个进程用多线程处理请求

五、实战建议

避免线程/进程数过多：

线程数：I/O 密集型任务线程数可设为 CPU 核心数的 5-10 倍
进程数：CPU 密集型任务进程数不宜超过 CPU 核心数

使用线程池/进程池：避免频繁创建销毁线程/进程，用池化技术提高效率：

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor# 线程池示例
with ThreadPoolExecutor(max_workers=4) as executor:results = executor.map(fetch_url, urls)