Python中的并发编程（多线程 vs 多进程 vs 异步编程）

1. 问题描述

并发编程是Python中处理多任务的核心技术，但Python由于GIL（全局解释器锁）的存在，多线程在CPU密集型任务中效率受限。因此，开发者需要根据任务类型选择合适方案：

• 多线程：适合I/O密集型任务（如网络请求、文件读写）。
• 多进程：适合CPU密集型任务（如计算、图像处理）。
• 异步编程：适合高并发的I/O操作，通过单线程内切换任务避免阻塞。

2. 核心概念与适用场景

（1）多线程（threading模块）

• 原理：多个线程共享同一进程的内存空间，由GIL控制同一时刻仅一个线程执行Python字节码。
• 适用场景：任务大部分时间在等待I/O操作（如爬虫、Web服务器处理请求）。
• 缺点：GIL导致多线程无法利用多核CPU并行计算。

示例代码：

import threading
import time

def task(name):
    print(f"{name} started")
    time.sleep(2)  # 模拟I/O操作
    print(f"{name} finished")

threads = []
for i in range(3):
    t = threading.Thread(target=task, args=(f"Thread-{i}",))
    threads.append(t)
    t.start()

for t in threads:
    t.join()  # 等待所有线程结束

（2）多进程（multiprocessing模块）

• 原理：每个进程有独立的内存空间和Python解释器，绕过GIL限制，真正并行执行。
• 适用场景：CPU密集型任务（如数据计算、图像处理）。
• 缺点：进程创建和上下文切换开销较大，内存占用更多。

示例代码：

import multiprocessing

def compute(n):
    return sum(i * i for i in range(n))

if __name__ == "__main__":
    with multiprocessing.Pool(processes=2) as pool:
        results = pool.map(compute, [10**6, 10**7])
    print(f"Results: {results}")

（3）异步编程（asyncio库）

• 原理：单线程内通过协程（Coroutine）切换任务，遇到I/O阻塞时自动切换到其他任务。
• 适用场景：高并发I/O操作（如大量网络连接）。
• 缺点：需要兼容异步的库（如aiohttp），代码需用async/await语法。

示例代码：

import asyncio

async def fetch_data(id):
    print(f"Fetching data {id}...")
    await asyncio.sleep(1)  # 模拟异步I/O
    print(f"Data {id} received")
    return id

async def main():
    tasks = [fetch_data(i) for i in range(3)]
    results = await asyncio.gather(*tasks)
    print(f"All results: {results}")

asyncio.run(main())

3. 性能对比与选择策略

选择策略：

1. I/O密集型：优先考虑异步编程（效率最高），或多线程（代码简单）。
2. CPU密集型：必须使用多进程。
3. 混合任务：可结合多进程（处理计算）与异步/多线程（处理I/O）。

4. 实战技巧与注意事项

1. 避免GIL陷阱：
   • 多线程中，若任务涉及C扩展（如NumPy）可能释放GIL，可间接实现并行。
2. 进程间通信（IPC）：
   • 使用multiprocessing.Queue、Pipe或共享内存（Value/Array）传递数据。
3. 异步编程要点：
   • 避免在协程中调用阻塞操作（如time.sleep），需用await asyncio.sleep()。
   • 使用async with和async for管理异步资源。

通过理解三者差异，结合实际任务需求，才能高效解决Python并发问题。