摘要：本文介绍了Python中的多进程编程方法，重点对比了多进程与多线程的差异。多进程通过利用多个CPU核心实现真正并行，能有效规避Python的GIL限制。文章详细讲解了三种启动进程的方式（Fork/Spawn/Forkserver），以及守护进程、进程终止和进程标识等核心概念。同时介绍了通过继承Process类创建自定义进程，以及使用Pool类实现进程池管理的方法。通过代码示例展示了进程创建、执行和结果获取的完整流程，为Python开发者提供了实用的多进程编程指南。

目录

Python 中的并发 —— 多进程

多进程（Multiprocessing）

多线程（Multithreading）

多进程与多道程序设计的区别

消除全局解释器锁（GIL）的影响

Python 中启动进程的三种方式

基于 Fork 创建进程

示例：使用 fork () 创建子进程

示例：跨平台的子进程创建方式

基于 Spawn 创建进程

示例：Spawn 创建多个进程

基于 Forkserver 创建进程

Python 中的守护进程

示例：创建守护进程

Python 中终止进程

示例：终止子进程

Python 中标识当前进程

示例：获取主进程和子进程的 PID

基于子类创建进程

子类创建进程的注意事项

示例：继承 Process 类创建进程

Python 多进程模块的 Pool 类

核心方法说明

示例：进程池的使用

---

Python 中的并发 —— 多进程

本章我们将重点对比多进程与多线程的差异，同时讲解 Python 中多进程的核心使用方法。

多进程（Multiprocessing）

多进程指在单个计算机系统中使用两个或多个 CPU 单元，它是充分利用计算机硬件性能的最优方式，能最大化发挥系统中所有 CPU 核心的算力。

多线程（Multithreading）

多线程是 CPU 通过并发执行多个线程来管理操作系统资源的能力，其核心思想是将一个进程拆分为多个线程，以此实现并行处理。

多进程与多道程序设计的区别

下表列出了二者的核心差异：

表格

多进程（Multiprocessing）	多道程序设计（Multiprogramming）
由多个 CPU同时处理多个进程	单个 CPU 下，将多个程序保存在主存并并发执行
利用多个 CPU资源	仅利用单个 CPU资源
支持并行处理	依靠上下文切换实现多任务
任务处理耗时更短	任务处理耗时更长
能高效利用计算机系统的各类设备	资源利用率低于多进程
系统部署成本通常更高	系统部署成本更低

消除全局解释器锁（GIL）的影响

在开发 Python 并发应用时，存在一个核心限制 ——全局解释器锁（GIL）。GIL 会阻止 Python 程序利用 CPU 的多个核心，因此严格来说 Python 中并不存在 “真正的线程”。

GIL 本质是一个互斥锁，用于保证线程安全，它限制了同一时间只有一个线程能执行 Python 代码：任何线程要执行代码，必须先获取这把锁。

而多进程机制能有效绕开 GIL 的限制，原因如下：

1. 多进程会创建多个独立的进程，每个进程都拥有自己的 Python 解释器和 GIL 实例；
2. 因此，程序中不同进程的字节码可以在同一时间无限制地并行执行。

Python 中启动进程的三种方式

Python 的multiprocessing模块提供了三种启动进程的方法，适用于不同场景和平台：

1. Fork（分支）
2. Spawn（生成）
3. Forkserver（分支服务器）

基于 Fork 创建进程

Fork是 UNIX 系统的标准命令，用于创建名为子进程的新进程，子进程会与父进程并发运行，且完全继承父进程的所有资源和属性。

创建 Fork 进程时会用到以下系统调用：

• fork()：由操作系统内核实现的系统调用，用于创建一个与父进程完全相同的子进程副本；
• getpid()：返回当前调用进程的进程 ID（PID），用于标识唯一进程。

示例：使用 fork () 创建子进程

注意：os.fork仅在基于 UNIX/Linux 的系统中可用。

# main.py
from multiprocessing import Process
import os

def child():
    n = os.fork()
    if n > 0:
        print("父进程的PID是: ", os.getpid())
    else:
        print("子进程的PID是: ", os.getpid())

child()

输出结果：

plaintext

父进程的PID是:  178462
子进程的PID是:  178463

示例：跨平台的子进程创建方式

以下脚本可在所有平台运行，实现子进程创建并获取父子进程的 PID：

# main.py
from multiprocessing import Process
import os

def child():
    print("子进程的PID是: ", os.getpid())

if __name__ == "__main__":
    print("父进程的PID是: ", os.getpid())
    # 创建子进程对象
    p = Process(target=child)
    # 启动子进程
    p.start()

输出结果：

plaintext

父进程的PID是: 25989
子进程的PID是: 25990

基于 Spawn 创建进程

Spawn意为 “生成”，指由父进程创建一个全新的子进程，父进程可选择异步继续执行，或等待子进程执行完毕后再继续。

Spawn 创建进程的步骤：

1. 导入multiprocessing模块；
2. 创建进程对象；
3. 调用start()方法启动进程；
4. 调用join()方法，让父进程等待子进程执行完成并退出。

示例：Spawn 创建多个进程

以下脚本实现生成 3 个独立的子进程：

import multiprocessing

def spawn_process(i):
    print('这是进程: %s' % i)
    return

if __name__ == '__main__':
    Process_jobs = []
    for i in range(3):
        p = multiprocessing.Process(target=spawn_process, args=(i,))
        Process_jobs.append(p)
        p.start()
        p.join()

输出结果：

plaintext

这是进程: 0
这是进程: 1
这是进程: 2

基于 Forkserver 创建进程

Forkserver（分支服务器）机制仅在部分支持 Unix 管道传递文件描述符的 UNIX 平台可用，其工作原理如下：

1. 启用 Forkserver 机制时，会先实例化一个服务器进程；
2. 该服务器进程专门接收创建新进程的指令，并处理所有相关请求；
3. Python 主程序需创建新进程时，向 Forkserver 发送请求，由服务器进程完成创建；
4. 新进程创建后，即可在主程序中调用使用。

Python 中的守护进程

Python 的multiprocessing模块通过daemonic参数支持创建守护进程，守护进程是在后台运行的进程，其设计理念与守护线程一致。

要让进程在后台运行，只需将daemonic标志设为True。守护进程的生命周期与主进程绑定：主进程运行时，守护进程持续执行；主进程结束（或被终止）时，守护进程会自动终止，无论其是否执行完成。

示例：创建守护进程

本示例沿用守护线程的逻辑，仅将模块从multithreading替换为multiprocessing并设置daemonic=True，输出结果会与守护线程有明显差异：

# main.py
import multiprocessing
import time

def nondaemonProcess():
    print("启动非守护进程")
    time.sleep(8)
    print("结束非守护进程")

def daemonProcess():
    while True:
        print("Hello")
        time.sleep(2)

if __name__ == '__main__':
    nondaemonProcess = multiprocessing.Process(target=nondaemonProcess)
    daemonProcess = multiprocessing.Process(target=daemonProcess)
    # 设置为守护进程
    daemonProcess.daemon = True
    # 非守护进程（默认值）
    nondaemonProcess.daemon = False

    daemonProcess.start()
    nondaemonProcess.start()

输出结果：

plaintext

启动非守护进程
结束非守护进程

结果解析：与守护线程的输出不同，本示例中守护进程未打印任何内容。原因是主进程会等待非守护进程执行完成后直接退出，守护进程也随之自动终止，避免了后台进程持续运行的问题。

Python 中终止进程

使用terminate()方法可立即强制杀死 / 终止进程，该方法可在子进程执行完成前，直接终止其运行。

示例：终止子进程

# main.py
import multiprocessing
import time

def Child_process():
    print('启动子进程函数')
    time.sleep(5)
    print('完成子进程函数')

P = multiprocessing.Process(target=Child_process)
P.start()

print("主进程即将终止，开始终止子进程")
print("终止子进程中...")
P.terminate()
print("子进程已成功终止")

输出结果：

plaintext

主进程即将终止，开始终止子进程
终止子进程中...
子进程已成功终止

结果解析：子进程函数本应休眠 5 秒后打印内容，但terminate()方法直接终止了它，因此无相关输出，说明子进程被成功终止。

Python 中标识当前进程

操作系统中每个进程都有唯一的 ** 进程 ID（PID）** 作为标识，在 Python 中可通过以下代码获取当前进程的 PID：

import multiprocessing
print(multiprocessing.current_process().pid)

示例：获取主进程和子进程的 PID

# main.py
import multiprocessing
import time

def Child_process():
    print("子进程的PID是: {}".format(multiprocessing.current_process().pid))

if __name__ == '__main__':
    print("主进程的PID是: {}".format(multiprocessing.current_process().pid))
    P = multiprocessing.Process(target=Child_process)
    P.start()
    P.join()

输出结果：

plaintext

主进程的PID是: 9401
子进程的PID是: 9402

基于子类创建进程

与通过继承threading.Thread创建线程的方式类似，Python 也支持通过继承multiprocessing.Process类自定义子类来创建进程。

子类创建进程的注意事项

1. 定义Process类的新子类；
2. 重写构造方法__init__(self [,args])（可选，用于自定义初始化参数）；
3. 必须重写run(self [,args])方法，该方法是进程的核心执行逻辑；
4. 调用start()方法启动进程（start()会自动调用重写后的run()方法）。

示例：继承 Process 类创建进程

# main.py
import multiprocessing

class MyProcess(multiprocessing.Process):
    def run(self):
        print('在进程中调用run方法: %s' % self.name)
        return

if __name__ == '__main__':
    jobs = []
    for i in range(5):
        P = MyProcess()
        jobs.append(P)
        P.start()
        P.join()

输出结果：

plaintext

在进程中调用run方法: MyProcess-1
在进程中调用run方法: MyProcess-2
在进程中调用run方法: MyProcess-3
在进程中调用run方法: MyProcess-4
在进程中调用run方法: MyProcess-5

Python 多进程模块的 Pool 类

对于 Python 应用中的简单并行处理任务，multiprocessing模块提供的Pool类是最优选择。Pool类用于创建进程池，通过预创建多个子进程，避免频繁创建 / 销毁进程的性能开销，其核心方法如下：

核心方法说明

表格

方法	功能说明
apply()	与ThreadPoolExecutor.submit()类似，阻塞式执行任务，直到获取结果后才继续
apply_async()	异步非阻塞方法，适合任务并行执行，提交任务后不阻塞主线程，直到所有子进程执行完毕
map()	与内置map()函数功能一致，阻塞式执行，将可迭代数据切分为多个分片，作为独立任务提交到进程池
map_async()	是map()的异步版本，与apply_async()对应apply()的逻辑一致；返回结果对象，结果就绪后可触发回调函数，且回调函数必须立即执行，否则会阻塞结果处理线程

示例：进程池的使用

以下示例实现进程池的并行计算，通过multiprocessing.Pool调用square()函数计算数字的平方，利用pool.map()提交任务并获取结果：

# main.py
import multiprocessing

def square(n):
    result = n * n
    return result

if __name__ == '__main__':
    # 待计算的输入数据：0-4的整数列表
    inputs = list(range(5))
    # 创建包含4个进程的进程池
    pool = multiprocessing.Pool(processes=4)
    # 提交任务到进程池
    pool_outputs = pool.map(square, inputs)
    # 关闭进程池，不再接收新任务
    pool.close()
    # 等待所有子进程执行完成
    pool.join()
    # 打印结果
    print('进程池计算结果: ', pool_outputs)

输出结果：

plaintext

进程池计算结果:  [0, 1, 4, 9, 16]