Python 并发

在现代编程中，充分利用系统资源以提高程序性能是一个重要的目标。

Python提供了多种并发编程的方式，包括多线程、多进程和异步I/O。

多线程：轻量级的并发

Python的threading模块允许程序创建线程，这些线程可以并发执行。由于Python的全局解释器锁（GIL），在任何给定时间点，只有一个线程可以执行Python字节码。因此，多线程更适合I/O密集型任务，比如文件操作和网络请求。

import threading

def fetch_data():
    print(f"Thread {threading.current_thread().name} is fetching data.")

# 创建线程
thread1 = threading.Thread(target=fetch_data, name='Thread-1')
thread2 = threading.Thread(target=fetch_data, name='Thread-2')

# 启动线程
thread1.start()
thread2.start()

# 等待线程完成
thread1.join()
thread2.join()

可参考：Python 多线程

多进程：绕过GIL的限制

对于CPU密集型任务，可以使用multiprocessing模块创建多个进程。每个进程有自己的内存空间和Python解释器，因此可以真正并行执行，不受GIL的限制。

from multiprocessing import Process

def process_data(data):
    print(f"Process {Process().pid} is processing data: {data}")

# 创建进程
process1 = Process(target=process_data, args=(1,))
process2 = Process(target=process_data, args=(2,))

# 启动进程
process1.start()
process2.start()

# 等待进程完成
process1.join()
process2.join()

可参考：Python 多进程

异步I/O：单线程并发

asyncio模块提供了一个事件循环，允许单线程并发执行多个任务。这对于I/O密集型任务非常有用，特别是在网络编程中。使用async和await关键字，可以编写非阻塞的异步代码。

import asyncio

async def fetch_data_async(data):
    print(f"Fetching data: {data}")
    await asyncio.sleep(1)  # 模拟I/O操作
    return f"Data for {data}"

async def main():
    tasks = [fetch_data_async(i) for i in range(5)]
    results = await asyncio.gather(*tasks)
    print(results)

# 运行事件循环
asyncio.run(main())

选择合适的并发模型

并发模型	适用场景	优点	缺点	备注
多线程	I/O密集型任务 （网络请求、文件操作）	轻量级，资源共享，适用于I/O等待	受GIL影响，不适合CPU密集型任务	线程创建和销毁有开销
多进程	CPU密集型任务 （大量计算）	绕过GIL，真正并行执行	重量级，资源消耗大，进程间通信复杂	适合多核CPU
异步I/O	高并发网络编程	单线程内高效管理多个I/O任务	代码复杂，需要异步库支持	适合大量并发连接，每次连接处理时间短

在选择并发模型时，需要考虑以下因素：

1. 任务类型：判断任务是I/O密集型还是CPU密集型。如果是纯I/O密集型，优先选择asyncio；如果是纯CPU密集型，优先选择ProcessPoolExecutor；如果是混合型任务，考虑使用ThreadPoolExecutor。
2. 性能要求：对于CPU密集型任务，多进程往往更合适；对于I/O密集型任务，多线程或异步I/O可能更有优势。
3. 开发效率：多线程模型开发较复杂，需要注意线程安全问题；多进程模型则更容易实现进程间的隔离。
4. 系统资源：考虑可用的处理器核心数，内存和网络资源。多进程会复制父进程的内存空间，因此如果内存使用已经很高，创建大量进程可能会导致内存不足。
5. 代码复杂度：异步I/O需要先有合适的异步库或框架的支持，而且编写异步I/O的代码相对较复杂。
6. 现有代码：考虑现有代码是否易于改造为异步，是否需要与同步代码交互。
7. 并发量：考虑并发量有多大，是否需要跨进程通信。