Day 9: Python 多线程与多进程性能优化实践
在现代计算环境中，充分利用多核 CPU 是提升程序性能的重要手段。Python 提供了多线程（threading）和多进程（multiprocessing）两种并发处理方式，但由于 GIL（全局解释器锁）的限制，了解何时使用哪种方法显得尤为重要。今天，我们将深入探讨 Python 的并发模型，揭示多线程与多进程的适用场景和优化技巧。
GIL 的影响：多线程的局限性
Python 的 GIL 是一种机制，保证同一时间只有一个线程可以执行 Python 字节码。虽然这为内存管理提供了安全性，但也限制了 Python 的多线程性能。
GIL 的特性：
- CPU 密集型任务：线程间竞争 GIL，无法利用多核 CPU。
- IO 密集型任务：由于 GIL 在 IO 操作时会释放，多线程能带来性能提升。
多线程与多进程的选择
1. 多线程（threading 模块）
适合 IO 密集型任务，如文件读写、网络请求：
import threading
import time
def download_file(file_id):
print(f"Downloading file {file_id}...")
time.sleep(2) # 模拟下载
print(f"File {file_id} downloaded!")
threads = []
for i in range(5):
t = threading.Thread(target=download_file, args=(i,))
threads.append(t)
t.start()
for t in threads:
t.join() # 等待线程完成
2. 多进程（multiprocessing 模块）
适合 CPU 密集型任务，如复杂计算：
from multiprocessing import Process
def compute_factorial(n):
result = 1
for i in range(1, n + 1):
result *= i
print(f"Factorial of {n} is {result}")
processes = []
for i in range(1, 6):
p = Process(target=compute_factorial, args=(i * 5,))
processes.append(p)
p.start()
for p in processes:
p.join()
如何优化并发性能？
1. 使用线程池和进程池
线程池和进程池通过重用线程/进程，减少创建开销，提升效率：
- 线程池（concurrent.futures.ThreadPoolExecutor）
适合网络爬虫、文件下载等任务：
from concurrent.futures import ThreadPoolExecutor
def download(file_id):
print(f"Downloading file {file_id}...")
time.sleep(2)
print(f"File {file_id} downloaded!")
with ThreadPoolExecutor(max_workers=5) as executor:
executor.map(download, range(10))
- 进程池（concurrent.futures.ProcessPoolExecutor）
适合图像处理、数值计算等任务：
from concurrent.futures import ProcessPoolExecutor
def square(n):
return n * n
with ProcessPoolExecutor() as executor:
results = executor.map(square, range(10))
print(list(results))
2. 异步 IO（asyncio 模块）
对于大量 IO 操作，异步编程可以避免线程开销，提高性能：
import asyncio
async def fetch_data(url):
print(f"Fetching {url}...")
await asyncio.sleep(2) # 模拟网络请求
print(f"Data fetched from {url}")
async def main():
tasks = [fetch_data(f"url_{i}") for i in range(5)]
await asyncio.gather(*tasks)
asyncio.run(main())
3. 降低竞争与冲突
- 避免多个线程/进程争夺同一资源，例如使用队列：
from queue import Queue
from threading import Thread
def worker(queue):
while not queue.empty():
task = queue.get()
print(f"Processing {task}")
queue.task_done()
task_queue = Queue()
for i in range(10):
task_queue.put(f"Task {i}")
threads = [Thread(target=worker, args=(task_queue,)) for _ in range(3)]
for t in threads:
t.start()
task_queue.join()
优化实践：案例分析
案例1：图片批量处理
假设我们有 10,000 张图片需要压缩，如何选择合适的并发模型？
- 多线程：如果图片存储在网络磁盘，使用多线程下载和处理。
- 多进程：如果图片在本地并且需要进行复杂压缩，使用多进程提高 CPU 利用率。
from PIL import Image
from concurrent.futures import ProcessPoolExecutor
def compress_image(image_path):
img = Image.open(image_path)
img.save(image_path.replace('.jpg', '_compressed.jpg'), quality=50)
with ProcessPoolExecutor() as executor:
executor.map(compress_image, ["image1.jpg", "image2.jpg", ...])
案例2：日志文件分析
如果需要分析 GB 级日志文件，多线程读取文件，多进程分析内容可以实现高效处理。
今天的总结与任务
学会灵活选择和使用 Python 的多线程、多进程和异步 IO，可以显著提高程序的并发能力和性能。
实践任务：
- 使用多线程编写一个爬取 10 个网页的爬虫，并统计总耗时。
- 使用多进程实现一个简单的矩阵乘法运算程序，测试其在多核 CPU 上的表现。
预告：
明天我们将进入更高阶的性能优化领域，探索 Python 的 C 扩展模块如何进一步提升代码运行效率。
用并发解锁 Python 的性能潜力，让开发更畅快！