Process类与多进程创建

Python并发编程专题 · 利用多核CPU的真正并行

专题：Python并发编程系统学习

关键词：Python, 并发编程, multiprocessing, Process, 多进程, fork, spawn, 进程管理

一、为什么需要多进程

Python的全局解释器锁（GIL）是CPython实现中的一个互斥锁，它保证同一时刻只有一个线程执行Python字节码。这意味着即使你创建了多个线程，在CPU密集型任务中它们也无法真正并行执行。多进程通过创建独立的Python解释器进程，完美绕过了GIL的限制，让每个进程都可以在一个独立的CPU核心上同时运行。

对于CPU密集型任务——比如大规模数值计算、图像处理、数据压缩、机器学习训练等——多进程是Python中的首选方案。每个子进程拥有独立的GIL，可以充分利用多核CPU的计算能力，实现真正的并行计算。相比之下，多线程更适合IO密集型任务，如网络请求、文件读写等。

多进程的另一个关键优势是地址空间隔离。每个进程运行在独立的内存空间中，一个进程的崩溃不会影响其他进程，这也避免了多线程编程中常见的数据竞争、死锁等同步问题。当然，独立的地址空间也意味着进程间通信（IPC）比线程间通信更复杂，需要借助Queue、Pipe、共享内存等机制。

二、Process类创建进程

multiprocessing.Process是Python标准库提供的进程创建类，其使用方式与threading.Thread非常相似。创建进程时，通过target参数传入要执行的函数，args参数传入函数参数（元组形式）。

from multiprocessing import Process

def cpu_work(n):
    return sum(i*i for i in range(n))

if __name__ == '__main__':
    p = Process(target=cpu_work, args=(10_000_000,))
    p.start()
    p.join()

start()方法启动子进程，操作系统会创建一个新进程并开始执行target函数。join()方法让主进程等待子进程结束，类似于线程中的join()。如果主进程需要获取子进程的返回值，不能直接通过target函数的return获取，而需要通过Queue、Pipe或共享内存等进程间通信机制。

下面是一个更完整的示例，演示如何创建多个进程并分配任务：

import multiprocessing as mp
import time

def worker(name, delay):
    print(f"进程 {name} 开始工作")
    time.sleep(delay)
    print(f"进程 {name} 完成工作")

if __name__ == '__main__':
    processes = []
    for i in range(4):
        p = mp.Process(target=worker, args=(i, 2))
        processes.append(p)
        p.start()

    for p in processes:
        p.join()

    print("所有进程已完成")

注意：在Windows上，target函数必须位于模块顶层，并且所有创建进程的代码必须放在if __name__ == '__main__'保护块中。这是因为Windows使用spawn方式启动进程，会重新导入模块。

三、继承Process类

除了向Process传递target函数外，还可以通过继承Process类并重写run()方法来定义子进程行为。这种面向对象的方式更适合封装复杂的处理逻辑和状态。

from multiprocessing import Process

class Worker(Process):
    def __init__(self, n):
        super().__init__()
        self.n = n

    def run(self):
        result = sum(i*i for i in range(self.n))
        print(f"计算结果: {result}")

if __name__ == '__main__':
    w = Worker(n=5_000_000)
    w.start()
    w.join()

继承Process类时需要特别注意：

务必调用super().__init__()以确保父类正确初始化，否则进程无法正常启动。
重写的是run()方法而非start()方法。start()内部会调用run()，并且还会执行启动进程所需的底层操作。
子类中可以定义任意属性和方法，在run()内部使用。

函数式创建（使用target）和继承式创建各有优劣：函数式更简洁灵活，适合简单任务；继承式更适合封装复杂业务逻辑、需要维护状态的场景。

四、三种启动方法详解

multiprocessing模块支持三种启动子进程的方法（start method），可通过multiprocessing.set_start_method()设置，或通过get_context()获取指定启动方式的上下文。

启动方法	原理	性能	安全性	平台支持
fork	子进程复制父进程全部内存空间（包括所有资源、文件描述符、锁状态）	最快，零拷贝启动	最低，可能因锁状态复制导致死锁	Unix/Linux（macOS默认可能禁用）
spawn	从头启动一个新Python解释器进程，仅导入必要模块	最慢，每次需重新初始化	最高，无共享状态冲突	Unix/Linux + Windows
forkserver	先启动一个服务器进程，当需要新进程时由服务器进程fork	中等，避免重复导入	较高，服务器进程较干净	Unix/Linux（支持Python 3.4+）

选择建议：在同一程序中不要混用不同的启动方法，全局设置一次即可。开发阶段建议优先使用spawn，因为它能暴露更多潜在的兼容性问题。生产环境中，Linux上的forkserver通常是性能和安全性之间的较好平衡。

import multiprocessing as mp

# 在程序入口设置启动方法（全局生效）
mp.set_start_method('spawn')

# 或使用 get_context 获取特定启动方式的上下文
ctx = mp.get_context('fork')
p = ctx.Process(target=worker)

在Python 3.8+中，macOS上fork的默认行为已被修改，spawn成为macOS的默认启动方法，这是由于fork在共享库环境中的安全性问题。

五、进程属性与生命周期

每个Process实例都提供了一组属性用于查询和控制进程状态：

pid：进程ID（操作系统分配的进程标识符），进程启动后才有效。
name：进程名称，可自定义，用于调试和日志标识。
daemon：守护进程标志（布尔值）。设置为True时，主进程退出时该子进程会被强制终止。必须在start()之前设置。
exitcode：进程退出码。None表示尚未退出，0表示正常退出，正数表示异常退出，负数表示被信号终止。

进程生命周期管理方法：

start()：启动进程，调度操作系统创建子进程。
terminate()：强制终止进程（Unix上发送SIGTERM信号，Windows上调用TerminateProcess）。使用需谨慎，被终止的进程不会执行清理代码。
kill()：Python 3.7+引入，更强制地终止进程（Unix上发送SIGKILL信号）。
is_alive()：检查进程是否仍在运行。
close()：Python 3.7+引入，显式释放与进程关联的资源。调用后进程对象不再可用。

from multiprocessing import Process
import time

def long_task():
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        print("进程被中断")

if __name__ == '__main__':
    p = Process(target=long_task, daemon=True)
    p.start()
    print(f"进程ID: {p.pid}")
    print(f"是否存活: {p.is_alive()}")
    time.sleep(2)
    p.terminate()
    p.join()
    print(f"退出代码: {p.exitcode}")
    p.close()

注意：daemon进程需要在start()之前设置。守护进程不能创建子进程，且会在主进程退出时被强制终止。daemon标志适用于那些不需要单独清理的后台任务。

六、进程退出与资源清理

正确管理进程退出和资源清理对于构建稳定的应用程序至关重要。核心挑战在于确保所有子进程都被正确回收，避免僵尸进程和资源泄漏。

join()的作用：主进程调用p.join()会阻塞等待子进程p结束。这不仅确保了主进程在逻辑上正确地等待子任务完成，更重要的是让操作系统知道该进程的退出状态已被收集，从而清理进程表条目。如果不调用join()，已结束的子进程会变成僵尸进程，占用系统进程表空间。

使用with语句管理进程（Python 3.6+）：

from multiprocessing import Process

def task():
    print("执行任务")

if __name__ == '__main__':
    with Process(target=task) as p:
        p.start()
        p.join()
    # with块结束后自动调用 close()

with语句会在退出时自动调用close()方法释放资源，但不会自动调用join()或terminate()。如果需要确保进程结束，仍需在with块内手动调用join()。

超时处理：join()方法支持timeout参数，设置等待超时时间。超时后，主进程可以决定是否强制终止子进程：

if __name__ == '__main__':
    p = Process(target=some_task)
    p.start()
    p.join(timeout=5)
    if p.is_alive():
        print("任务超时，强制终止")
        p.terminate()
        p.join()

七、if name == 'main'的重要性

在Python的multiprocessing模块中，if __name__ == '__main__'保护块不是一个可选项，而是一个必要约定。其原因与Python的模块导入机制和进程启动方式密切相关。

spawn模式的工作原理：当使用spawn启动方式时（Windows上的默认方式，macOS上的推荐方式），子进程会启动一个全新的Python解释器，并重新导入主模块。如果在模块顶层直接编写创建进程的代码，子进程在导入模块时会再次执行这些代码，导致无限递归地创建进程，最终触发RuntimeError异常。

# 错误示例 — 缺少保护块，在Windows上会报错
from multiprocessing import Process

def worker():
    print("子进程工作")

p = Process(target=worker)
p.start()
p.join()

# 在 Windows 上运行会递归创建进程，导致 RuntimeError

# 正确示例
from multiprocessing import Process

def worker():
    print("子进程工作")

if __name__ == '__main__':
    p = Process(target=worker)
    p.start()
    p.join()
# 子进程不会执行保护块内的代码

即使主要运行在Linux/macOS上（默认使用fork），也建议始终加上if __name__ == '__main__'保护。这样代码能够跨平台兼容，且在使用set_start_method('spawn')或forkserver时不会出现问题。

最佳实践总结：始终将进程创建和启动代码放在if __name__ == '__main__'保护块内；优先使用spawn或forkserver启动方式以获得更好的安全性和跨平台兼容性；对于需要返回结果的任务，使用Queue或Pool.map()；合理设置daemon标志和join()超时时间，避免进程泄漏。