Python 并发编程：threading、multiprocessing 和 asyncio 的应用与优劣
大家好，今天我们来深入探讨 Python 中的并发编程，重点关注 threading、multiprocessing 和 asyncio 这三个核心模块，分析它们在不同场景下的应用、优劣以及如何根据实际需求选择合适的并发模型。
1. 并发与并行：概念辨析
在深入具体模块之前，我们需要明确并发（Concurrency）和并行（Parallelism）这两个概念的区别。
-
并发（Concurrency）: 指的是在一段时间内，多个任务看起来像是同时在执行。实际上，它们可能是在时间片上交替执行，利用 CPU 的空闲时间。
-
并行（Parallelism）: 指的是在同一时刻，多个任务真正地在不同的 CPU 核心上同时执行。
简单来说，并发是逻辑上的同时发生，而并行是物理上的同时发生。
2. threading：多线程
threading 模块是 Python 中实现多线程编程的标准库。线程是操作系统能够进行运算调度的最小单位，它存在于进程之中，并共享进程的资源。
2.1 threading 的基本使用
import threading
import time
def task(name, delay):
print(f"线程 {name} 开始执行")
time.sleep(delay)
print(f"线程 {name} 执行完毕")
if __name__ == "__main__":
thread1 = threading.Thread(target=task, args=("Thread-1", 2))
thread2 = threading.Thread(target=task, args=("Thread-2", 3))
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print("所有线程执行完毕")在这个例子中，我们创建了两个线程 thread1 和 thread2，它们分别执行 task 函数。start() 方法启动线程，join() 方法阻塞主线程，直到子线程执行完毕。
2.2 线程同步：锁机制
由于多个线程共享进程的资源，因此需要考虑线程同步问题，以避免数据竞争和死锁等情况。threading 模块提供了锁（Lock）机制来实现线程同步。
import threading
import time
shared_resource = 0
lock = threading.Lock()
def increment(name, num_increments):
global shared_resource
for _ in range(num_increments):
with lock: # 使用上下文管理器确保锁的释放
shared_resource += 1
print(f"线程 {name}: shared_resource = {shared_resource}")
time.sleep(0.01)
if __name__ == "__main__":
thread1 = threading.Thread(target=increment, args=("Thread-1", 500))
thread2 = threading.Thread(target=increment, args=("Thread-2", 500))
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print(f"最终 shared_resource 的值为: {shared_resource}")在这个例子中，我们使用 threading.Lock() 创建了一个锁对象 lock。通过 with lock: 语句，我们确保在修改共享资源 shared_resource 时，只有一个线程可以访问临界区，从而避免了数据竞争。
2.3 threading 的优缺点
| 特性 | 优点 | 缺点 |
|---|---|---|
| 易用性 | 简单易用，Python 标准库自带，无需额外安装。 | |
| 资源占用 | 线程共享进程的资源，创建和销毁线程的开销较小。 | |
| 并发性 | 能够并发执行 I/O 密集型任务，例如网络请求、文件读写等。 | 由于 GIL (Global Interpreter Lock) 的存在，Python 的多线程无法真正地并行执行 CPU 密集型任务，只能利用单核 CPU。 |
| 线程安全性 | 需要手动处理线程同步问题，例如锁、信号量等。 | 容易出现死锁、数据竞争等问题，需要仔细设计。 |
| 适用场景 | 适用于 I/O 密集型任务，例如网络爬虫、Web 服务器等，这些任务通常需要等待 I/O 操作完成，线程可以利用等待时间执行其他任务。 | 不适用于 CPU 密集型任务，因为 GIL 会限制多线程的并行性。 |
| GIL 的影响 | Python 的 GIL 保证了同一时刻只有一个线程可以执行 Python 字节码。这简化了 CPython 解释器的实现，但也限制了多线程的并行性。对于 CPU 密集型任务，多线程并不能提高性能，甚至可能因为线程切换的开销而降低性能。 |
2.4 结论
threading 适用于 I/O 密集型任务，但受限于 GIL，不适用于 CPU 密集型任务。需要注意线程同步问题，避免数据竞争和死锁。
3. multiprocessing：多进程
multiprocessing 模块是 Python 中实现多进程编程的标准库。进程是操作系统分配资源的基本单位，每个进程拥有独立的内存空间。
3.1 multiprocessing 的基本使用
import multiprocessing
import time
def task(name, delay):
print(f"进程 {name} 开始执行")
time.sleep(delay)
print(f"进程 {name} 执行完毕")
if __name__ == "__main__":
process1 = multiprocessing.Process(target=task, args=("Process-1", 2))
process2 = multiprocessing.Process(target=task, args=("Process-2", 3))
process1.start()
process2.start()
process1.join()
process2.join()
print("所有进程执行完毕")在这个例子中，我们创建了两个进程 process1 和 process2，它们分别执行 task 函数。start() 方法启动进程，join() 方法阻塞主进程，直到子进程执行完毕。
3.2 进程间通信：Queue 和 Pipe
由于多个进程拥有独立的内存空间，因此需要使用进程间通信（IPC）机制来实现数据共享。multiprocessing 模块提供了 Queue 和 Pipe 两种 IPC 方式。
-
Queue: 进程安全的队列，可以用于多个进程之间的数据传递。
-
Pipe: 管道，可以用于两个进程之间的单向或双向数据传递。
import multiprocessing
import time
def producer(queue):
for i in range(5):
message = f"Message-{i}"
print(f"生产者发送消息: {message}")
queue.put(message)
time.sleep(1)
def consumer(queue):
while True:
message = queue.get()
print(f"消费者接收消息: {message}")
if message == "Message-4":
break
time.sleep(2)
if __name__ == "__main__":
queue = multiprocessing.Queue()
producer_process = multiprocessing.Process(target=producer, args=(queue,))
consumer_process = multiprocessing.Process(target=consumer, args=(queue,))
producer_process.start()
consumer_process.start()
producer_process.join()
consumer_process.join()
print("生产者和消费者执行完毕")在这个例子中，producer 进程将消息放入队列 queue 中，consumer 进程从队列中取出消息。multiprocessing.Queue 保证了进程间数据传递的安全性。
3.3 multiprocessing 的优缺点
| 特性 | 优点 befor | 优点 |
|---|