multiprocessing

multiprocessing 提供与 threading 相近的 API，但每个子进程拥有 独立的 Python 解释器与 GIL，适合 CPU 密集型 纯 Python 计算占满多核。需要「把任务丢给进程池、按需取结果」时，可配合 concurrent.futures.ProcessPoolExecutor；进程间传数据常用 Queue / Pipe（底层 pickle 序列化）。I/O 密集 仍常优先线程或 asyncio。

适用性：在 wasm32-emscripten / wasm32-wasi 上 不可用（见 WebAssembly 平台）。

何时用多进程

与线程的取舍：多进程 内存隔离，一个子进程崩溃不必然拖垮整个解释器；但创建慢、对象须可 pickle，且默认 不共享 普通 Python 对象。与 内置类型线程安全 互补——跨进程仍须自行设计通信与一致性。

直接运行的 Python 脚本默认是单进程、单线程的；multiprocessing 会在需要时额外 fork/spawn 子进程。

模块成员总览

模块级函数与常量

类型与通信 / 同步

子模块：multiprocessing.shared_memory（命名共享内存）、multiprocessing.connection（底层连接）。

创建与等待进程

import multiprocessing as mp

def worker(n):
    print(f"process {n}")

if __name__ == '__main__':
    p = mp.Process(target=worker, args=(1,), name="worker-1")
    p.start()   # 同 Thread：每对象只能 start 一次
    p.join()    # 阻塞直到结束；可设 timeout，超时后用 exitcode / is_alive 判断

start()、join()、terminate() 等 只能由创建该 Process 的进程 调用。

if __name__ == '__main__' 为何必需

在 Windows 与 macOS 默认 spawn 下，子进程会 重新 import 主模块 再执行 run()。若入口代码无保护，会无限递归创建进程。Pool、交互式 REPL 中在顶层定义的函数也常因 无法 pickle 而失败——把 worker 与 if __name__ == '__main__' 写在 可 import 的模块 里是常见写法。

from multiprocessing import Pool

def f(x):
    return x * x

if __name__ == '__main__':
    with Pool(5) as p:
        print(p.map(f, [1, 2, 3]))  # [1, 4, 9]

启动方法：spawn / fork / forkserver

import multiprocessing as mp

if __name__ == '__main__':
    mp.set_start_method('spawn')          # 全局一次
    ctx = mp.get_context('spawn')       # 或显式上下文，便于同程序混用多种方法
    q = ctx.Queue()

不同上下文创建的对象可能不兼容（例如 fork 下创建的锁不能传给 spawn 子进程）。库代码宜用 get_context()，避免覆盖用户选择。POSIX 上 spawn / forkserver 会启动 资源追踪器，清理泄漏的命名信号量、共享内存段。

进程间通信

队列 Queue

from multiprocessing import Process, Queue

def f(q):
    q.put([42, None, 'hello'])

if __name__ == '__main__':
    q = Queue()
    p = Process(target=f, args=(q,))
    p.start()
    print(q.get())  # [42, None, 'hello'] — 新对象，非共享内存
    p.join()

• 放入的对象 pickle 序列化；get() 得到的是 副本。
• empty() / full() / qsize() 在多进程下 不可靠（竞态）。
• JoinableQueue：每 get() 后须 task_done()，再 join() 等待全部完成。
• 异常 queue.Empty / queue.Full 须从标准库 queue import（不在 multiprocessing 命名空间）。

管道 Pipe

from multiprocessing import Process, Pipe

def f(conn):
    conn.send([42, None, 'hello'])
    conn.close()

if __name__ == '__main__':
    parent_conn, child_conn = Pipe()
    p = Process(target=f, args=(child_conn,))
    p.start()
    print(parent_conn.recv())
    p.join()

duplex=False 时为单向。两端 同时 读/写同一端可能损坏数据；send/recv 对不可信对端有反序列化风险，生产环境需认证（见官方「认证密码」）。

同步与共享状态

官方建议：能消息传递就不要共享可变状态。若必须共享：

共享内存 Value('d', 0.0)、Array('i', range(10))：ctypes typecode（如 'd' 双精度、'i' 整型），进程与线程安全，适合数值数组。

管理器 Manager()：独立服务进程托管 dict / list / Lock / Queue 等，经代理操作；更灵活、可跨机器，但 更慢。with Manager() as manager: 自动启动与关闭服务进程。

from multiprocessing import Process, Lock

def f(lock, i):
    with lock:
        print('hello', i)

if __name__ == '__main__':
    lock = Lock()
    for num in range(4):
        Process(target=f, args=(lock, num)).start()

Lock、Condition、Event、Barrier 等与 threading 同名类型行为类似，均支持 with lock: 上下文管理器。

进程池 Pool

from multiprocessing import Pool, TimeoutError
import time

def f(x):
    return x * x

if __name__ == '__main__':
    with Pool(processes=4) as pool:
        print(pool.map(f, range(10)))           # 阻塞，有序结果
        for i in pool.imap_unordered(f, range(10)):
            print(i)                              # 迭代，顺序任意
        res = pool.apply_async(f, (20,))
        print(res.get(timeout=1))                 # 400
    # 退出 with 后池关闭，不可再用

池只能由创建它的进程使用。AsyncResult.get(timeout=...) 超时时抛出 multiprocessing.TimeoutError。

相关模块速查

易错点（排错速记）

• 省略 if __name__ == '__main__'：Windows/macOS spawn 下递归起进程或 import 副作用重复执行。
• 在 REPL / notebook 顶层用 Pool：worker 函数须可 pickle，常报 Can't get attribute 'f'。
• 把多进程当多线程用共享全局变量：子进程是拷贝/重新 import，修改不会回写父进程（除非 Value/Manager/队列）。
• terminate 时正在用 Queue：队列可能损坏，其他进程 get 异常。
• 子进程往 Queue put 后未消费就 join 子进程：可能死锁（缓冲区未刷完）；Manager 队列或确保消费完毕。
• 多线程 + fork：易死锁或崩溃；改用 spawn 或 forkserver，或先起进程再在该进程内建线程。
• 混用不同 get_context() 的锁与队列：跨上下文对象不兼容。
• CPU 不重但进程很多：启动与 pickle 开销可能抵消收益；I/O 密集优先线程/asyncio。
• WebAssembly：本模块不可用。

资料：multiprocessing 文档