外观
多进程为何启动失败或越跑越慢:创建方式、序列化与任务粒度
摘要
日志统计换成进程池后,本机提示无法序列化,换平台又出现全局变量不同步。本文从可运行的批处理实验出发,解释进程如何创建、参数怎样传递,以及为什么并行收益必须覆盖启动和通信成本。
验证环境: Windows x64,CPython 3.14.0 常规 GIL 构建;同一独立示例亦已在 CPython 3.13.7 运行通过。实验显式采用spawn;进程创建与传输时间是本机观测,不代表Linux默认方式或普遍加速收益。
场景:线程没加速,改成进程又遇到新问题
这是教学场景。一个日志统计工具主要花时间运行 Python 循环,开发者决定把每条记录交给进程池。为了方便,任务函数写成主函数里的 lambda。Windows 上提交失败;另一个环境中改成顶层函数可以运行,但处理很小的记录时,进程池比顺序执行还慢。
从线程切到进程,先改掉一项默认假设:任务不再直接拿着当前对象和活动调用栈执行,而要在独立环境中重新找到函数、取得数据并把结果传回。判断顺序是“子进程从哪里开始→函数和参数怎样重建→计算收益能否覆盖传输与归并”。lambda失败属于第二步,小任务更慢属于第三步;两者不能统称为进程池故障。
本文主线 CPython 3.14 常规构建,示例显式使用 spawn,方便不同平台复现。默认方式的变化单独解释,不能把示例采用的方式当成所有系统默认值。实验是有界计算,只有两个工作进程,没有外部服务。
进程创建方式决定子进程从哪里开始
spawn 可以理解为启动新的解释器,再按协议建立工作环境。子进程需要能够导入任务所需的模块,函数定义必须可以被重新找到。父进程当前执行到哪个局部作用域,子进程不会自动获得同样的活动调用栈。它获得的是启动信息和传递的数据。
fork 是 POSIX 上的一种创建方式,子进程开始时继承父进程地址空间的逻辑内容。copy-on-write(写时复制)让部分页面初始可以共享,只在修改时产生相应复制,因此“继承大量数据”不一定等于立即物理复制全部内存。但普通 Python 对象仍不是父子自动同步的一份共享对象;任何一方修改后,另一方不会因此看到同样业务状态。
fork 的危险还包括多线程父进程。子进程只保留调用 fork 的线程,但某些锁和运行时状态可能来自其他已经不在子进程里运行的线程。如果继承到“某锁已被持有”的状态,而持有者不会继续执行,就可能挂住。这是为什么不能把它当成所有后端进程都适合的启动优化。
forkserver 使用一个专门服务进程来创建工作进程,避免直接从已经复杂多线程化的业务父进程派生。它也不意味着父进程后来修改的任意全局状态都会自动传到工作进程。理解它的价值要看创建来源,而不是只记住名字里有 fork。
图表将在阅读到此处时加载…
3.14 默认方式变化:先查完整环境
根据官方 multiprocessing 文档,fork 从 3.14 起不再是任何平台的默认创建方式。常见 Windows 和 macOS 环境仍使用 spawn;3.14.0 的常见其他 Unix/POSIX 环境改为 forkserver,还要看平台是否提供它需要的能力。3.14 发布说明给出了迁移背景。
我们阅读的在线 /3.14/ 文档还包含 3.14.9 的更新:没有可写临时目录的相应环境下,默认可退回 spawn。这不是 3.14.0 原始行为。部署迁移时要记录补丁版本、OS、可用创建方式和实际上下文,不能引用一段当前页面正文覆盖所有 3.14 补丁。
公共库更适合允许调用方提供 multiprocessing context(创建上下文,确定进程与相关同步对象的创建方式),而不是在导入时无条件修改整个程序默认值。不同上下文创建的对象也未必可以随意混用。主程序知道资源与线程环境,应该拥有最终选择权。
“改回 fork 就好了”也不是结束。如果问题是任务依赖不可传递的连接,fork 可能让它表面存在,却把数据库或 socket 的状态带进不安全的复用方式。要修复任务接口与资源所有权,而不是仅绕过启动报错。
pickle 怎样把函数与数据送过去
serialization(序列化)把对象变成可传递的表示,deserialization(反序列化)在接收方重新建立对象。标准库进程池使用的机制涉及 pickle。对于常规顶层函数,pickle 主要依据可定位的模块和名称引用函数,而不是把任意函数体、局部调用环境和外部资源打包复制过去。
先保持算法 value*value 不变,只把callable从主函数里的lambda换成可导入模块中的顶层函数。普通pickle主要保存模块和名称,前者缺少可供另一解释器重新找到的稳定位置,后者具备。参数仍必须是可序列化的数据;实例中夹带锁、文件或连接时,顶层函数也不能替它们建立安全的跨进程所有权。
队列传递的对象一般是重新创建的对象,不与原对象共享普通内存身份。官方队列说明强调了序列化及后台发送带来的时序特点。将字典放进队列之后,再修改本地字典,不应依赖接收方看到某个特定修改时刻;更稳妥的是把提交的数据视为不可再修改的任务快照。
序列化也不是安全边界。pickle 输入可以触发危险行为,不能反序列化不可信来源的任意数据。本篇只在同一个受控程序里用它演示任务可定位性。跨信任边界的数据协议应选明确的数据格式与校验,不能照搬进程池内部机制。
最小实验:拒绝局部 callable,显式 spawn,按批归并
保存以下完整代码为 docs/python/examples/20_processes.py,用脚本方式运行,避免在交互会话里定义任务导致子进程不能导入。
python
"""Use explicit spawn and top-level callables; compare equal amounts of work."""
from concurrent.futures import ProcessPoolExecutor, wait, FIRST_COMPLETED
import multiprocessing as mp
import pickle
import time
import platform
from concurrent.futures.process import BrokenProcessPool
import os
def crash_worker():
os._exit(7) # Teaching injection, only in the isolated pool child.
def sum_squares(numbers):
return sum(number * number for number in numbers)
def bounded_sum(pool, chunks):
source, pending, total = iter(chunks), set(), 0
exhausted = False
while pending or not exhausted:
while len(pending) < 2 and not exhausted:
try:
chunk = next(source)
except StopIteration:
exhausted = True
else:
pending.add(pool.submit(sum_squares, chunk))
if pending:
done, pending = wait(pending, return_when=FIRST_COMPLETED)
total += sum(future.result() for future in done)
return total
def main():
numbers = list(range(20_000))
expected = sum_squares(numbers)
try:
pickle.dumps(lambda value: value * value)
except (pickle.PicklingError, AttributeError) as error:
print("local callable rejected:", type(error).__name__)
else:
raise AssertionError("standard pickle unexpectedly accepted lambda")
print("available:", mp.get_all_start_methods())
print("environment:", platform.platform(), platform.python_version(), os.cpu_count())
context = mp.get_context("spawn") # Do not rely on platform/version defaults.
chunks = [numbers[index:index + 5000] for index in range(0, len(numbers), 5000)]
start = time.perf_counter()
with ProcessPoolExecutor(max_workers=2, mp_context=context) as pool:
total = sum(pool.map(sum_squares, chunks))
elapsed = time.perf_counter() - start
assert total == expected
print("start method:", context.get_start_method())
print("result:", total, "seconds including startup:", round(elapsed, 6))
for size in (200, 2000, 20000):
chunks = [numbers[i:i + size] for i in range(0, len(numbers), size)]
start = time.perf_counter()
sequential = sum(map(sum_squares, chunks))
baseline = time.perf_counter() - start
start = time.perf_counter()
with ProcessPoolExecutor(max_workers=2, mp_context=context) as pool:
parallel = bounded_sum(pool, chunks) # At most two outstanding futures.
duration = time.perf_counter() - start
assert parallel == sequential == expected
print("matrix:", size, len(chunks), "sequential_s", baseline, "pool_s", duration)
with ProcessPoolExecutor(max_workers=1, mp_context=context) as pool:
future = pool.submit(crash_worker)
try:
future.result(timeout=5)
except BrokenProcessPool:
print("child exit propagated: BrokenProcessPool; recreate only after diagnosis")
else:
raise AssertionError("child failure was not propagated")
if __name__ == "__main__":
main()powershell
python docs/python/examples/20_processes.py运行前沿任务走三站:普通pickle尝试定位lambda而失败;显式spawn建立工作解释器,顶层sum_squares处理传入批次;父进程取得局部整数并归并,结果与同输入顺序计算一致。代码断言核对可定位性、上下文和总结果。异常类、耗时及可用方式列表有环境差异,因此输出不是通用固定文本,更不预先承诺进程版较快。
反例是把带隐含局部环境的 callable 当成可跨进程任务;正例是顶层函数、明确数据参数、显式上下文和父进程归并。入口保护 if __name__ == '__main__' 避免子进程导入主模块时再次无条件创建进程池,产生递归启动。
实验计时包括进程创建、提交、执行和关闭。它只展示这一组输入的完整成本,不证明进程版本一定更快。代码没有为了制造漂亮结果把顺序版本计时含入数据生成、而把进程版本的数据生成排除在外;比较优化收益时仍要给两者安排相同工作范围。
任务粒度决定通信是否值得
设每个任务的有效计算时间为 C,调度与通信开销为 S。若每条日志仅需很少计算,而提交、序列化和返回每次都要付出 S,那么增加任务数会让总开销变大。并行度不能消除父进程提交与归并的成本,也不能让通道无限快。
用同一两万项输入比较粒度,才看得出传输成本:每项一个任务会反复支付调度与通信费用,四批则让每个sum_squares完成更多有效计算,只返回一个整数,父进程依然归并到同一总结果。真实日志也可返回局部计数,而非每条记录的大对象。减少的不是算法必需信息,而是重复交接;随后还要检查大批次的负载不均、取消和重试代价。
但批太大也有代价:一个批次特别慢会拖延整体完成,取消反应变慢,故障重试需要重做更多工作。负载均衡要看记录处理成本分布,而不仅是行数。若部分记录需要昂贵解析,按固定条数分批未必均衡,可能要估算数据量、动态分配或按成本拆分。
性能选择应该通过曲线而不是单点做。固定相同数据,比较顺序基线、不同批大小与不同工作进程数;观察总耗时、峰值内存、父进程 CPU 和结果正确性。只有工作量足够大且瓶颈可并行,启动和传输成本才有可能被摊薄,这是一条条件推断,不是具体加速比例。
输入数据本身也可能昂贵。父进程先把整个大文件读入巨型列表,再把完整列表复制给每个工作进程,峰值内存可能远高于流式分批。第 11 篇的流式模型与这里组合时,应有界读取、提交和回收结果,不能只把文件迭代器交给无法正确重建的工作环境。
共享内存、Manager 与连接所有权
共享内存允许多个进程映射同一内存区域,适合某些大块数值数据,减少重复序列化。它不是自动把任意 Python 对象图变成共享对象:必须定义数据布局、同步和释放协议,所有进程对字节解释要一致,创建者与使用者要约定何时结束生命周期。
Manager 提供代理访问由服务进程管理的对象,写起来像访问共享字典,但每次操作可能跨进程通信。代理的方便不能消除延迟,也不能自动让“先读后写”的组合成为事务。高频细粒度访问可能把本来并行的计算收束到一个通信瓶颈。
数据库连接和 HTTP 客户端连接通常应在实际使用它的工作进程里建立与关闭。父进程创建的活连接不能因子进程拥有类似对象就默认安全。任务初始化可以复用每个工作进程自己的资源,但必须设置故障恢复和退出清理,避免每条小任务都重新建立昂贵连接。
如果业务包含写入副作用,工作进程异常后重试需要考虑是否已经部分成功。future 的失败只能说明调用方没有得到正常结果,不等于外部操作未发生。使用唯一业务标识、幂等约束和明确提交点,比一味增加重试次数更重要。
故障与退出也是进程协议的一部分
关闭进程池通常要明确不再提交任务,并等待已有工作结束。等待中的任务、排队任务和已经开始的任务拥有不同取消能力。超时返回不保证工作进程停止;强制终止又可能留下不完整文件或外部半完成事务。
进程间队列还可能有后台发送线程。只看 put 返回,不能认定数据已经到达消费端;只看 empty(),也不能建立可靠的完整工作计数协议。应使用明确数量、结束标识和确认关系,避免通过瞬时队列状态猜测全部任务结束。
异常诊断先区分提交前序列化失败、子进程导入失败、任务业务异常和进程意外退出。它们的修复层不同。把所有错误都包装成“进程池坏了”,会丢失最有价值的原始 traceback。示例在父进程消费返回结果,确保执行异常不会被忽略。
一份任务跨进程时,哪些身份会改变
父进程里两个名称指向同一对象,只描述父进程的引用关系。任务参数被序列化并重建后,子进程拿到自己的对象;即使数值相等,也不能用两边的 id 证明共享身份。id 的意义属于相应进程和对象生命期,不是跨进程可比较的全局对象编号。
类似地,某个配置字典在工作进程里变更,通常不会自动更新父进程的同名字典。结果应通过返回值、队列或明确共享协议交回,不能在任务内部改全局变量然后期待父进程读到更新。这种误用在简单 fork 演示中尤其容易被忽略,因为初始内容看起来继承了,却没有后续同步。
任务异常也跨越通信边界。父进程通过 future 看到的异常,包含工作进程返回的信息,但不意味着可以直接检查子进程所有局部对象。需要保持异常链与任务标识,必要时在子进程记录脱敏阶段信息。若子进程意外结束而无法正常序列化结果,得到的失败类型可能与业务主动抛错不同,诊断要保留这种区分。
端到端成本怎么拆,才能找到真正的串行瓶颈
把批处理拆成读取、构造参数、发送、执行、返回、归并和关闭。只测工作函数,可能得出“每批很快”;整体却因父进程不断复制大参数而很慢。观察父进程 CPU 与工作进程利用率,可以提出发送和归并是否跟得上的候选原因,再用减少数据量的实验验证。
假设工作进程同时很空闲,父进程却忙于序列化,就不应继续增大工作进程数。若所有工作进程忙,但末尾只剩一个巨大批次运行,可能是负载不均。若吞吐增长伴随内存明显上涨,应检查提交积累、结果未消费和复制份数,而不只看核心数。
沿同一数据再追到归并者:worker计算完成不等于参数和结果已经无人持有。全部结果先转列表会让父进程保存本可逐项释放的数据;示例只有少量整数,这项风险不明显,巨型列表结果则可能主导内存。流式处理迁移过来时,需要读取、提交、消费三侧同时有界;对象保留也要按父子进程分别查,不能拿一个进程的差分解释全部复制份数。
初始化与重用:昂贵资源应该放在哪个阶段
若每批都加载相同大型模型,可以考虑工作进程初始化阶段建立本地资源,后续任务复用。这样减少重复准备,但增加每个进程常驻内存,并需要处理初始化失败与生命周期。父进程预加载后依赖 fork 继承不是跨平台通用方案,尤其在3.14默认方式变化后更不能靠隐含状态。
初始化资源还应与配置版本绑定。常驻工作进程不会自动重新读取父进程的新字典;热更新需要明确通知或重建池,并考虑进行中的任务属于哪个版本。若新旧资源交错,结果需要能够归属相应配置,避免把迁移期间的差异当成随机算法错误。
当任务依赖数据库或网络,进程数应受外部容量限制。两个进程各开二十条连接,外部看到的是四十条;多个应用实例再相乘。并行 CPU 能力不代表下游连接无限,进程隔离也不取消总资源预算。容量计算和限流要按部署拓扑完成。
为什么脚本成功,交互环境却失败
交互解释器中的函数定义可能只存在于当前会话,spawn工作进程没有同样可导入的主模块内容。Notebook、REPL和某些IDE运行器有各自执行方式,不能以它们和普通脚本共用一个界面,就推断进程启动环境相同。本文坚持保存为脚本,正是为了让函数定位和入口保护可复现。
若发布为命令行工具,还要确认任务函数位于安装后可导入的模块,工作进程使用预期解释器和包版本。父进程导入成功,不足以证明子进程搜索路径完全一致。错误消息里的模块名、解释器路径和启动方式,应作为部署证据保留,而不是用捕获所有异常返回零来绕开。
输出日志也要标明进程身份。多个进程可能同时打印,同一行前后次序不是业务执行总顺序。结果归并应依赖任务标识和明确返回协议,不能通过stdout文本猜测哪个进程先完成、哪个结果已被持久化。
容易踩的坑与面试推演
第一坑是缺入口保护,或者在模块顶层创建池;spawn 导入就可能重复启动。第二坑是把全局变量当任务配置,在池启动后才修改它,期待所有子进程立即看到;应通过参数或明确初始化协议传递配置。
第三坑是以为切换到 fork 就能让进程池接受 lambda。即使工作进程通过 fork 创建,Pool 和 ProcessPoolExecutor 仍要通过任务队列序列化函数及参数,普通 pickle 的可定位性要求不会消失。直接以 fork 创建 Process 时继承目标函数,是另一种启动路径,不能将它的行为套到池任务提交。第四坑是给每条微小记录开独立进程,完全没有摊薄启动成本。修复需要进程池和批处理,但进程池也必须结合资源上限,不能无限积累待执行参数。
面试问“多进程为何能绕过常规 GIL 的计算限制”,应解释独立解释器与地址空间,同时补上资源、通信和 OS 调度成本。问“fork 是否等于内存免费共享”,要区分写时复制与业务状态同步。问“为什么函数不能 pickle”,要回答模块与名称定位,而不是只背“lambda 不行”。
同工作量矩阵与子进程异常闭环
矩阵的 bounded_sum 只维护最多两个待完成 Future,填满窗口后等待 FIRST_COMPLETED,读取结果再继续消费输入迭代器。这样同时演示3.13与3.14可用的有界提交协议;它限制的是未归并任务数,不是本例已经物化的输入列表。若进一步处理大文件,应把上游分批读取也改成有界生成器,避免只限制池队列却在父进程先保留整个文件。
粒度对照采用200、2000、20000三种批大小,对同一 20000 项输入比较顺序与两个 spawn worker。顺序侧同样按这些批切分,并归并为相同总数;进程侧计时包括启动、任务发送、执行和关闭。程序打印任务数、两侧秒数和环境。它是一轮教学矩阵,没有置信区间,也没有证明某批大小对真实服务最优。这个小工作量常由启动成本主导,但是否更慢以你的原始输出为准。
反例是把每项都提交为 Future,再只计 worker 内部循环;正例是先定义等价工作量和端到端范围,再评估粒度。共享内存或 initializer 复用可能降低某类费用,却会引入布局、资源所有权和关闭协议,应先确认瓶颈真在复制而非父进程归并。
另一个受控任务在独立子进程里调用 os._exit(7)。主进程读取其 Future,收到 BrokenProcessPool,说明工作进程非正常终止使池失效。它不同于普通业务 ValueError:后者可以通过任务结果传播,池不一定失效。线上要保存退出码、子进程 stderr、资源限制与任务标识,判断是否 OOM、外部信号或原生崩溃;此实验只注入退出,不冒充诊断真实 OOM。修复根因后重建池,不能向已失效池不断重试;写操作还须考虑是否已经产生副作用。
OS 写时复制解释 fork 继承的页面,不免除进程池任务协议中的序列化;流式生成器用于让读取、提交、归并都有边界,不能把生成器交给无限物化的接口就称为有界。
能力任务:保持总数据和结果不变,改变批大小及 worker 数,保存至少三轮端到端数据;再注入普通任务异常与工作进程退出。验收要求分别消费 Future、识别可继续使用的池与失效的池,提交未知结果副作用的重试策略。
一句话总结:进程并行先付创建和通信成本,只有合适的任务接口与粒度才能获得收益。
- 创建方式绑定完整版本与平台,公共库优先接受明确上下文。
- 顶层 callable、可序列化参数和入口保护是可复现进程任务的基础。
- 按批计算、最小结果归并与清晰资源所有权,比盲目增加进程数更重要。