第一次在 Windows 上用 multiprocessing,最容易遇到一个诡异现象:主脚本里的打印语句在子进程里又执行了一遍,一行日志出现好几次。如果主脚本里还包含「删除旧文件」「初始化数据库」这类动作,后果就不只是日志难看。

import multiprocessing as mp

print("开始处理")

def work(x):
    return x * x

if __name__ == "__main__":
    with mp.Pool(2) as p:
        print(p.map(work, range(5)))

在 Windows 上,get_start_method() 返回 spawn,get_all_start_methods() 只有 ['spawn']。spawn 的意思是「启动一个全新的 Python 解释器」,它不认识父进程内存里的任何东西,只能通过序列化把「要执行哪个函数、参数是什么」传过去,子进程再重新导入模块。既然要导入模块,模块顶层代码就会重新执行一遍。

这还是最表面的坑。我实测时还遇到更隐蔽的:函数定义在 if __name__ == "__main__" 块里面,子进程报 AttributeError: module '__mp_main__' has no attribute 'bump',父进程却只看到共享变量仍然是 0,没有异常提示。任务静默失败,结果悄悄不对。这篇就把多进程的启动、序列化、通信和进程池的边界一次讲清。

进程和线程先分清

进程是操作系统分配资源的基本单位,每个进程有独立的内存空间;线程是进程内的执行单元,同一进程的线程共享内存。Python 的全局解释器锁(GIL)让同一进程内同一时刻只有一个线程执行字节码,所以纯 Python 的 CPU 密集任务,多线程并不能利用多核。多进程绕开这个限制:每个进程有自己的解释器和 GIL,可以真正并行。

代价也很直接。进程启动比线程重得多,Windows 上 spawn 一个进程要重新导入模块、初始化解释器,几十毫秒起步。进程之间不共享内存,传数据要序列化再反序列化,大对象传输的成本可能超过并行省下的时间。进程崩溃互不影响是优点,但一个子进程悄悄死掉,父进程不一定知道,这也是排查困难的来源。

选择标准可以简化成三句话:CPU 密集、需要多核,用多进程;I/O 密集、大量等待,用多线程或异步;需要频繁共享复杂状态,先考虑单进程内的数据结构,别一上来就上多进程。系统层面的进程调度、内存隔离、创建开销,在进程管理那篇里有更完整的解释。

启动方式:spawn、fork 与模块顶层代码

multiprocessing 支持几种启动方式,不同平台默认值不同。Windows 只有 spawn;Linux 和 macOS 上历史默认是 fork,较新版本出于安全考虑在逐步调整默认值。代码里不要假设平台默认值,需要确定行为时用 get_context("spawn") 显式创建上下文。

spawn

启动全新解释器,重新导入主模块。跨平台行为一致,但启动慢;要求目标函数和参数都能被序列化,且函数必须定义在模块顶层。Windows 默认。

fork

复制父进程内存,启动快,能继承已有状态。但多线程父进程 fork 后容易死锁,某些库的状态也会被复制坏。只在明确知道风险时使用。

spawn 带来的第一条硬规则:主脚本必须有 if __name__ == "__main__": 保护。子进程导入模块时会执行顶层代码,没有保护就会递归创建进程,或者重复执行初始化逻辑。第二条硬规则:给 Process 或进程池的目标函数,必须定义在模块顶层,不能在函数内部、不能在 __main__ 块里、不能是 lambda。

def bump(val):
    for _ in range(10000):
        with val.get_lock():
            val.value += 1

if __name__ == "__main__":
    v = mp.Value("i", 0)
    ps = [mp.Process(target=bump, args=(v,)) for _ in range(2)]
    for p in ps:
        p.start()
    for p in ps:
        p.join()
    print(v.value)

上面这段的 bump 在模块顶层,能正常工作。如果把 def bump 挪进 if __name__ 块,子进程会报找不到属性,父进程的 join 正常返回,值却还是 0。这个失败不会让父进程抛异常,因为子进程的启动异常发生在子进程内部,父进程只看到「进程结束了,退出码 0」。排查这类问题,第一件事是看子进程的 stderr,而不是只看父进程的返回值。

看到「结果不对但没报错」,先检查子进程是不是悄悄死了。给 Process 加 exitcode 检查,给进程池的 apply_async 结果加 .get(timeout=...),否则异常会被吞在结果对象里。

进程之间怎么传数据

进程不共享内存,最直接的通信方式是队列和管道。multiprocessing.Queue 是进程安全的队列,子进程 put,父进程 get;Pipe 是两端各一个连接,适合一对一的双向通信。两者传输的对象都要能被 pickle 序列化,普通的内置类型、模块顶层的类和函数都可以,打开的文件句柄、数据库连接、lambda 不行。

def put(q, v):
    q.put(v)

if __name__ == "__main__":
    q = mp.Queue()
    p = mp.Process(target=put, args=(q, "hello"))
    p.start()
    p.join()
    print(q.get(timeout=1))

输出 hello。get(timeout=1) 在队列空时抛 queue.Empty,别用无限等待,否则主进程会卡在一条永远不会来的消息上。子进程正常结束后队列里仍有数据,这是正常的:队列有自己的后台线程负责把数据刷给管道,父进程要先取完再退出。

进程池的返回值走另一套机制:pool.map 直接返回结果列表,apply_async 返回 AsyncResult,用 .get() 取结果。子进程里抛的异常会在 .get() 时重新抛出,所以不要只 start 不 get,异常会被静默留在结果对象里。用 with mp.Pool(...) 能保证退出时关闭池并等待任务结束。

需要共享可变状态时,可以用 Value、Array 或 Manager。Value 和 Array 是共享内存加锁的封装,适合少量计数;Manager 返回的字典、列表是代理对象,背后有一个管理进程,用起来像普通容器,但每次操作都有进程间通信开销,比本地容器慢一个数量级。能通过消息传递解决的,不要用共享内存;必须共享时,把共享范围压到最小。

共享计数一定要加锁。Value 的 value += 1 不是原子操作,多个进程同时读改写会丢更新。用 with val.get_lock(): val.value += 1 包起来。这一点和线程里的竞态是同一类问题,只是换成了进程边界。

Pipe 比 Queue 更轻,适合固定的一对一通信。它返回两个连接对象,两端各自 send 和 recv;如果两个进程同时往同一端写,或者都先 recv 再 send,就可能互相等。规则是「一端写、另一端读」时最简单,双向通信要约定谁先发。队列适合多生产者多消费者,管道适合点对点,选错了会在压力下出现难以复现的阻塞。

进程池:什么任务适合放进去

进程池预先创建固定数量的工作进程,任务排队分发,省去反复创建进程的开销。常用接口有 map(同步,按顺序返回)、starmap(参数解包)、imap(返回迭代器,边算边取)、imap_unordered(谁先完成先返回)。map 会等所有任务完成才返回,imap 可以更早开始处理结果,内存占用也更低。

with mp.Pool(2) as p:
    print(p.map(square, range(5)))
    print(p.starmap(pow, [(2, 3), (3, 2)]))

with mp.Pool(2) as p:
    for r in p.imap_unordered(square, [3, 1, 2]):
        print(r)
[0, 1, 4, 9, 16]
[8, 9]

imap_unordered 的输出顺序取决于完成顺序,上例实际可能打印 1 4 9 或别的排列。需要保持顺序用 imap 或 map。任务粒度要合适:每个任务只有几十微秒的计算,序列化和调度开销会超过收益;把任务拆成「一批几条」用 chunksize 提交,通常比一条一个任务快。

进程池的大小不是越大越好。默认值通常是 CPU 核数,我机器上是 12。CPU 密集任务开到核数附近合理,再大只会增加切换和内存压力;I/O 密集任务用进程池本身就不划算,应该用线程或异步。池里的进程是长期存活的,任务之间如果有全局状态,会互相污染,别把「每次任务都重新初始化」的假设带进来。

确实需要每个进程初始化一次资源时,用 Pool(initializer=...),它会在每个工作进程启动时调用一次,适合建立数据库连接、加载只读配置。maxtasksperchild 可以让工作进程处理一定数量任务后退出并重建,用来缓解内存泄漏或第三方库的状态残留。代价是重建开销,设得太小会抵消池的价值,通常只在确认有泄漏时使用。

任务提交方式也影响内存。map 会先把整个可迭代对象转成列表再分发,结果也全部收集在内存里;imap 返回迭代器,边算边取。处理几十万条数据时,这个差别可能就是「跑得动」和「内存爆掉」的区别。用 chunksize 把任务按批提交,能减少调度次数,但批太大又会让负载不均,需要按任务耗时调整。

还有一个常见错误是在守护进程里创建进程池。守护进程不能有子进程,创建时会报 AssertionError: daemonic processes are not allowed to have children。多层并行要先想清楚谁负责创建、谁负责回收,不要让池套池。

把脚本打包成 Windows 可执行文件时,还要在入口调用 multiprocessing.freeze_support(),否则子进程可能反复启动主程序、弹出多个窗口。这是打包工具与 spawn 机制的交互问题,不加不会在源码运行阶段暴露,只在上线后出现。用 PyInstaller 这类工具时,把这一行放在 if __name__ == "__main__" 的最前面。

卡死与静默失败:几种真实原因

多进程最难查的不是报错,是卡住。下面几种情况我都见过,原因各不相同,但表面现象都是「程序不动了」。

第一种,队列的 join 顺序错了。子进程往队列里放数据,父进程先 join 子进程、再去 get,如果队列缓冲区满了,子进程会阻塞在 put 上,父进程阻塞在 join 上,两边互相等。正确顺序是先取完数据,再 join,或者用带超时的 get 并处理超时。

第二种,任务函数抛异常但没人取结果。apply_async 返回的结果对象不 get,异常就一直留在里面;父进程看到的是「任务提交成功」,实际什么都没算。用 map 或 imap 会好一些,异常在迭代时抛出,但也要确保迭代真的执行到那一项。

第三种,子进程静默退出。spawn 下函数不可序列化、导入模块失败、内存不足被系统杀掉,父进程可能只看到退出码,拿不到原因。给每个进程记录 exitcode,把子进程的 stderr 收集到日志,是排查的第一步。退出码为负通常表示被信号杀死,退出码为正则是进程自己退出。

退出码 0 也不代表任务成功。上面的例子里,子进程因为找不到函数而启动失败,父进程看到的仍然是「进程结束」,共享值没变。判断任务是否真的完成,要看业务结果或显式的完成信号,不能只看进程活着还是死了。给关键任务加一个「完成标记」,比盯着退出码可靠。

第四种,锁没释放。共享锁在 with 里用,异常时能自动释放;手动 acquire 之后忘记 release,下一次获取就永远等。跨进程的死锁比线程更难恢复,因为不能靠调试器暂停所有进程。设计上尽量少用共享锁,能用队列就用队列。

退出进程池也要干净。with 块结束会调用 terminate,正在跑的任务可能被直接打断,队列里的数据来不及刷出。需要「把手上的任务做完再退」时,先 close() 阻止新任务,再 join() 等现有任务完成;只有在卡死、确定不要结果时才用 terminate()。这个区别在定时任务、批处理脚本里很关键,用错会丢最后一批数据。

现象对照

现象真实原因第一步查什么
子进程里又打印了一遍主脚本日志spawn 重新导入模块,顶层代码重复执行把入口逻辑放进 if __name__ == "__main__"
Can't pickle <lambda>lambda 没有可导入的名字,无法序列化改成模块顶层的普通函数
module '__mp_main__' has no attribute ...目标函数定义在 __main__ 块或函数内部把函数移到模块顶层
结果不对但父进程没报错子进程启动失败,父进程只看到退出码检查每个进程的 exitcode 和子进程 stderr
程序卡在 join 不动队列满了,子进程阻塞在 put先取队列再 join,或给 get 加超时
apply_async 的任务像没执行没调用 .get(),异常被留在结果对象里对结果调用 get(timeout=...)
共享计数少了value += 1 不是原子操作用 get_lock() 包住读改写
守护进程里建池报 AssertionError守护进程不允许有子进程把建池放在主进程,调整进程拓扑
Linux 能跑、Windows 报错fork 与 spawn 的启动语义不同统一用 get_context("spawn") 复现

边界与代价

多进程的收益来自「真正并行」,代价来自「隔离」。每个进程独立的内存意味着数据要复制,传输大对象时内存峰值可能翻倍;进程间通信要走操作系统,延迟比函数调用高几个数量级。把任务切得太碎,调度和传输开销会吃掉并行收益。

启动成本决定了它不适合短任务。一个只跑几十毫秒的任务,spawn 一个进程可能就要几十毫秒,还不如单进程循环。进程池能摊薄启动成本,但池本身要保持存活,任务之间要有足够的量才划算。

调试成本也明显上升。断点只能停在一个进程里,日志会交错,异常栈跨进程时不完整。上线前要把日志加上进程标识,把关键输入输出记下来;出问题时先确认「哪个进程、在哪个阶段、退出码是多少」,再谈代码逻辑。

可移植性是另一条边界。fork 能跑通的代码,spawn 下可能因为序列化失败;Windows 的路径、权限、信号处理也和 Linux 不同。跨平台项目从一开始就用 spawn 语义写代码,本地开发和部署环境才一致。至少要有一台 Windows 或 CI 跑一遍,别等上线才发现。

最后是资源上限。每个进程有自己的解释器、内存和文件句柄,开太多会被系统限制。CPU 核数不是唯一指标,内存、文件句柄、下游服务的承受能力都要算进去。并发度是资源预算,不是越大越好的参数。

小结

多进程适合 CPU 密集任务;Windows 默认 spawn,会重新导入主模块,所以入口要放在 if __name__ == "__main__" 里,目标函数必须定义在模块顶层且可序列化;进程之间通过队列、管道、共享内存或 Manager 通信,优先消息传递;进程池用 map、imap、apply_async,记得取结果;卡死多半是队列顺序、锁没释放或子进程静默退出。

排查多进程问题的顺序:先看子进程是否活着(退出码、stderr),再看数据有没有传到(队列、结果对象),最后才怀疑算法。顺序反了,会在错误的地方浪费大量时间。还有一个通用原则:把「任务函数」写成纯函数,只依赖参数、不依赖全局可变状态,能避开一大半跨进程问题。

当天可以自己验证的练习:

  1. 写一个带 if __name__ == "__main__" 的主脚本,在顶层和块内各放一条打印,启动两个子进程,观察打印次数。
  2. 用 pool.map 传一个 lambda,记录 PicklingError 原文;改成顶层函数再跑一次。
  3. 把目标函数放进 if __name__ 块,启动进程并打印 exitcode,观察父进程是否报错。
  4. 用两个进程对同一个 mp.Value 各加一万次,先不加锁跑一次,再加锁跑一次,对比结果。
  5. 用 imap_unordered 提交三个耗时不同的任务,打印完成顺序,再换成 imap 对比。

下一篇讲多线程:GIL、threading、锁与队列。多进程解决「用不上多核」,多线程解决「等 I/O 时别闲着」。但 GIL 让多线程的适用场景很窄,什么能做、什么做了也白做,下一篇用实测数据说清楚。