python如何实现多进程编程_python multiprocessing模块多进程编程实践-Python教程-PHP中文网

Python多进程编程依赖multiprocessing模块，通过Process类或Pool进程池实现并行计算，有效规避GIL限制，适用于CPU密集型任务。

python如何实现多进程编程_python multiprocessing模块多进程编程实践

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并发编程的第一步，它直接决定了你选择多进程还是多线程。

豆包AI编程

豆包推出的AI编程助手

483

查看详情

使用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
```
登录后复制
能显著提升效率。