在现代计算环境中，充分利用多核 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 张图片需要压缩，如何选择合适的并发模型？

1. 多线程：如果图片存储在网络磁盘，使用多线程下载和处理。
2. 多进程：如果图片在本地并且需要进行复杂压缩，使用多进程提高 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，可以显著提高程序的并发能力和性能。

实践任务：

1. 使用多线程编写一个爬取 10 个网页的爬虫，并统计总耗时。
2. 使用多进程实现一个简单的矩阵乘法运算程序，测试其在多核 CPU 上的表现。

预告：
明天我们将进入更高阶的性能优化领域，探索 Python 的 C 扩展模块如何进一步提升代码运行效率。

用并发解锁 Python 的性能潜力，让开发更畅快！