Python多进程编程依赖multiprocessing模块，通过Process类或Pool进程池实现并行计算，有效规避GIL限制，适用于CPU密集型任务。
Python实现多进程编程主要依赖其内置的
multiprocessing模块。这个模块提供了一套API，允许我们创建并管理多个独立的进程，每个进程都有自己独立的内存空间，互不干扰。这对于充分利用多核CPU资源，尤其是在处理CPU密集型任务时，能够有效规避Python全局解释器锁（GIL）带来的性能瓶颈，从而实现真正的并行计算。
解决方案
要实现Python多进程编程，核心就是使用
multiprocessing模块。最基础的方式是利用
Process类来创建并启动新进程，就像我们在操作系统层面启动一个独立程序一样。
举个例子，假设我们有一个耗时的计算任务：
import os
import time
from multiprocessing import Process, Queue
def compute_heavy_task(name, duration, output_queue=None):
"""一个模拟耗时计算的函数"""
pid = os.getpid()
print(f"进程 {name} (PID: {pid}) 启动，将运行 {duration} 秒。")
start_time = time.time()
result = 0
for _ in range(int(duration * 1000000)): # 模拟CPU密集型计算
result += 1
end_time = time.time()
print(f"进程 {name} (PID: {pid}) 完成，耗时 {end_time - start_time:.2f} 秒。")
if output_queue:
output_queue.put(f"结果来自 {name}: {result}")
if __name__ == '__main__':
print(f"主进程 (PID: {os.getpid()}) 启动。")
# 创建一个队列用于进程间通信
results_queue = Queue()
# 创建并启动多个进程
process1 = Process(target=compute_heavy_task, args=('Worker-1', 2, results_queue))
process2 = Process(target=compute_heavy_task, args=('Worker-2', 3, results_queue))
process3 = Process(target=compute_heavy_task, args=('Worker-3', 1, results_queue))
process1.start() # 启动进程1
process2.start() # 启动进程2
process3.start() # 启动进程3
# 等待所有子进程完成
process1.join()
process2.join()
process3.join()
print("所有子进程已完成。")
# 从队列中获取结果
while not results_queue.empty():
print(results_queue.get())
print("主进程结束。")在这个例子里，我们定义了一个
compute_heavy_task函数，它模拟了一个CPU密集型操作。然后，在
if __name__ == '__main__':块中（这在Windows上是必须的，避免子进程无限递归创建），我们创建了三个
Process实例，分别指向这个函数，并通过
args传递参数。
start()方法启动进程，而
join()方法则让主进程等待子进程执行完毕。这里还引入了
Queue来演示进程间的简单通信，子进程可以将结果放入队列，主进程再从中取出。
立即学习“Python免费学习笔记（深入）”；
除了直接使用
Process类，
multiprocessing模块还提供了一个更高级、更方便的抽象——
Pool。
Pool可以创建一个工作进程池，自动管理这些进程的生命周期，并提供了
map、
apply、
starmap等方法，非常适合并行处理一系列独立任务。
import os
import time
from multiprocessing import Pool
def square(x):
"""一个简单的计算函数"""
pid = os.getpid()
print(f"进程 {pid} 正在计算 {x} 的平方...")
time.sleep(0.5) # 模拟一些工作
return x * x
if __name__ == '__main__':
print(f"主进程 (PID: {os.getpid()}) 启动。")
data = [1, 2, 3, 4, 5, 6, 7, 8]
# 创建一个包含4个工作进程的进程池
# 默认情况下，Pool会使用os.cpu_count()个进程
with Pool(processes=4) as pool:
# 使用map方法将data中的每个元素并行地传递给square函数
results = pool.map(square, data)
print("所有计算已完成。")
print("结果:", results)
print("主进程结束。")Pool的
map方法与内置的
map函数类似，但它会将可迭代对象中的元素分发给进程池中的各个进程并行处理，然后收集所有结果。这大大简化了并行任务的管理。
为什么在Python中多进程比多线程更适合CPU密集型任务？
这大概是很多初学者都会困惑的问题，甚至连我刚开始接触Python并发编程时也一度搞不清楚。说白了，核心原因在于Python的全局解释器锁（Global Interpreter Lock，简称GIL）。
GIL是CPython解释器（也就是我们最常用的Python实现）的一个特性，它在任何时刻都只允许一个线程执行Python字节码。这意味着，即使你的机器有多个CPU核心，一个Python进程内的多个线程也无法真正并行地执行Python代码。它们会轮流获取GIL，交替执行，这对于I/O密集型任务（比如网络请求、文件读写，因为等待I/O时线程会释放GIL）来说影响不大，甚至能提高效率。
然而，对于CPU密集型任务（比如复杂的数学计算、数据处理），线程之间会频繁地争抢GIL。一个线程好不容易拿到GIL开始计算，没多久可能就被迫释放GIL让给其他线程，然后又得重新竞争。这种频繁的上下文切换和锁的竞争，反而会引入额外的开销，导致多线程版本的程序可能比单线程版本还要慢。这听起来有点反直觉，但这就是GIL的现实。
多进程则不同。每个进程都有自己独立的Python解释器实例和内存空间。这意味着每个进程都有自己独立的GIL，它们之间互不影响。当一个进程执行CPU密集型任务时，它拥有自己的GIL，可以完全占用一个CPU核心进行计算，而其他进程也可以同时在其他CPU核心上独立运行。因此，多进程能够真正地利用多核CPU的并行计算能力，是解决Python中CPU密集型任务性能瓶颈的有效手段。我个人觉得，理解GIL是深入Python并发编程的第一步，它直接决定了你选择多进程还是多线程。
使用multiprocessing模块时，有哪些常见的陷阱和最佳实践？
multiprocessing模块虽然强大，但在实际使用中也有些“坑”和需要注意的地方。
常见的陷阱：
-
进程间数据共享的误解： 这是最常见的错误。进程拥有独立的内存空间，所以父进程的变量在子进程中是独立的副本，直接修改子进程中的变量不会影响父进程或其他子进程。如果需要共享数据，必须使用
multiprocessing
模块提供的特定机制，如Queue
（队列）、Pipe
（管道）、Value
（共享值）、Array
（共享数组）或者Manager
（管理器）。忘记这一点会导致数据不一致或逻辑错误。 -
Pickling问题： 进程间传递对象（通过
Queue
、Pipe
或Pool
的参数/返回值）时，这些对象必须是可序列化的（pickleable）。如果尝试传递一个不可序列化的对象（比如lambda函数、嵌套函数、某些自定义的复杂对象实例），程序会抛出TypeError
。 -
Windows系统下的
if __name__ == '__main__':
： 在Windows上，当你启动一个新进程时，Python会导入你的主模块。如果没有if __name__ == '__main__':
这个判断，子进程在导入模块时会再次执行所有顶层代码，包括创建新进程的代码，导致无限递归创建进程，直到系统资源耗尽。在Linux/macOS上，通常使用fork
方式创建进程，子进程会直接复制父进程的内存空间，所以不强制要求，但为了跨平台兼容性，始终使用这个判断是最佳实践。 -
死锁和竞态条件： 即使进程间内存隔离，但当多个进程尝试访问或修改共享资源（如
Queue
、Lock
）时，仍然可能发生死锁（进程相互等待对方释放资源）或竞态条件（操作顺序不确定导致结果错误）。这需要仔细设计进程间通信和同步机制。 -
进程创建开销： 创建一个新进程比创建线程的开销要大得多，因为它需要复制父进程的内存空间（或在
fork
模式下建立映射），并启动一个新的解释器。因此，不适合频繁地创建和销毁大量进程。
最佳实践：
-
优先使用
Pool
： 对于任务分发和结果收集的场景，Pool
比手动管理Process
实例要简洁高效得多。它会自动管理进程的生命周期，提供map
、apply
等方便的接口。 -
明确IPC策略： 如果需要进程间通信，提前规划好使用哪种IPC机制。
Queue
适合生产者-消费者模式，Pipe
适合双向通信，Lock
用于同步，Manager
则能创建可在多个进程间共享的Python对象。 - 最小化进程间通信： 进程间通信是有开销的。尽量设计任务，使得每个子进程能够独立完成大部分工作，只在必要时进行通信或共享少量数据，避免过度同步。
-
合理设置进程数量： 对于CPU密集型任务，通常将进程数量设置为CPU的核心数或略多一点（例如
os.cpu_count() + 1
），以充分利用硬件资源。过多的进程反而会因上下文切换开销而降低性能。 -
错误处理和超时机制： 在实际应用中，子进程可能会出错或长时间无响应。考虑使用
try...except
块捕获子进程中的异常，并为join()
或Pool
方法设置超时参数，防止程序无限等待。 -
考虑
concurrent.futures.ProcessPoolExecutor
： 这是Python标准库concurrent.futures
模块提供的一个更高级的抽象，它提供了与threading.ThreadPoolExecutor
相似的接口，可以更方便地在进程池中提交任务并获取结果，代码通常更简洁易读。
除了multiprocessing，Python还有哪些处理并发任务的工具或模式？
Python处理并发任务的工具和模式远不止
multiprocessing一个，它们各有侧重，适用于不同的场景。
threading
模块（多线程）： 这是Python处理并发最直接的方式之一。它允许在一个进程内创建多个执行线程。如前所述，由于GIL的存在，threading
在CPU密集型任务上无法实现真正的并行，但它在I/O密集型任务（如网络请求、文件读写、等待数据库响应等）中表现出色。当一个线程等待I/O时，它会释放GIL，允许其他线程运行，从而提高整体吞吐量。asyncio
模块（异步IO/协程）：asyncio
是Python处理单线程并发的强大工具，它基于协程（coroutine）和事件循环（event loop）。它不创建新的线程或进程，而是在单个线程中通过协作式多任务（cooperative multitasking）来实现并发。当一个协程遇到I/O等待时，它会“暂停”执行并将控制权交还给事件循环，事件循环会去执行其他就绪的协程。这种方式非常适合高并发的I/O密集型应用，比如网络服务器、爬虫等，因为它避免了线程/进程切换的开销，效率极高。-
concurrent.futures
模块： 这个模块提供了一个高层次的接口来异步执行可调用对象。它包含两个主要的执行器：ThreadPoolExecutor
：基于threading
模块，用于线程池。ProcessPoolExecutor
：基于multiprocessing
模块，用于进程池。 它提供submit()
方法提交任务，并返回Future
对象，通过Future
对象可以查询任务状态、获取结果或捕获异常。concurrent.futures
极大地简化了多线程和多进程编程的复杂性，提供了一致的API。
第三方库，例如
joblib
： 在科学计算和数据分析领域，joblib
库是一个非常实用的工具。它提供了一个简单的Parallel
类，可以方便地将for
循环并行化，底层可以选择使用多线程或多进程。对于那些需要对大量数据进行独立处理的场景，joblib
能显著提升效率。
对我来说，选择哪种工具，很大程度上取决于任务的性质。CPU密集型任务，我果断会考虑
multiprocessing或
concurrent.futures.ProcessPoolExecutor。I/O密集型任务则在
threading和
asyncio之间权衡，后者尤其适合需要处理大量并发连接的高性能网络服务。如果只是简单的并行化循环，
joblib的
Parallel用起来也相当顺手。理解这些工具的优缺点，才能在实际项目中做出最合适的选择。
