使用multiprocessing.Queue传递PythonOCC几何结果时脚本突然停滞

问题背景 #

使用PythonOCC创建复杂CAD几何模型，为提升计算速度、规避内存泄漏，采用multiprocessing.Process分批执行开孔切割操作，希望通过队列直接传递切割结果而非写入STEP文件，但程序执行少量迭代后突然停滞，无法继续。运行环境为Windows 11下的WSL2 Ubuntu、Anaconda环境中的JupyterLab，Python 3.11.5。

核心原因分析 #

1. PythonOCC对象序列化问题：PythonOCC的几何实体（如TopoDS_Shape）基于OpenCASCADE的C++对象，原生不支持Python的pickle序列化，而multiprocessing.Queue依赖序列化传递数据，直接传递会导致阻塞或序列化失败。
2. Queue使用的死锁风险：无论先调用get()还是join()，若子进程因序列化失败或异常挂起，主进程都会陷入无限等待；若队列满且子进程未完成写入，也会触发死锁。
3. Jupyter+WSL2的多进程兼容性：WSL2默认采用fork启动进程模式，PythonOCC依赖的C++库在fork后可能出现资源状态冲突，导致进程异常。

解决方案 #

方案1：改用进程池+STEP字节流传递（推荐） #

通过将切割后的模型转为STEP字节流（可序列化），主进程再解析回几何对象，避免直接传递C++绑定对象，同时用进程池简化管理。

import multiprocessing
import io
from OCC.Core.STEPControl import STEPControl_Writer, STEPControl_Reader, STEPControl_AsIs
from OCC.Core.Interface import Interface_Static_SetCVal

def cutting_function(block, *others):
    # 执行切割操作，得到处理后的几何形状
    processed_shape = ...  # 替换为你的切割逻辑
    
    # 将形状转为STEP格式字节流
    writer = STEPControl_Writer()
    Interface_Static_SetCVal("write.step.schema", "AP203")
    writer.Transfer(processed_shape, STEPControl_AsIs)
    buf = io.BytesIO()
    writer.WriteStream(buf)
    buf.seek(0)
    return buf.getvalue()

def step_bytes_to_shape(step_bytes):
    # 将STEP字节流解析为PythonOCC几何对象
    reader = STEPControl_Reader()
    buf = io.BytesIO(step_bytes)
    reader.ReadStream(buf)
    reader.TransferRoots()
    return reader.OneShape()

if __name__ == "__main__":
    list_blocks = ...  # 你的分批切割数据
    
    # 初始化进程池，进程数根据CPU核心和内存调整
    with multiprocessing.Pool(processes=2) as pool:
        # 分批处理，imap支持迭代获取结果
        for step_bytes in pool.imap(cutting_function, list_blocks):
            result = step_bytes_to_shape(step_bytes)
            # 后续处理result，比如合并到总模型

方案2：修复Queue使用逻辑（保留Process模式） #

若坚持使用Process，需添加异常捕获、超时机制，并转换数据格式避免序列化问题。

import multiprocessing
import io
from OCC.Core.STEPControl import STEPControl_Writer, STEPControl_Reader, STEPControl_AsIs
from OCC.Core.Interface import Interface_Static_SetCVal

def cutting_function(block, QQ, *others):
    try:
        # 执行切割操作
        processed_shape = ...
        
        # 转为STEP字节流
        writer = STEPControl_Writer()
        Interface_Static_SetCVal("write.step.schema", "AP203")
        writer.Transfer(processed_shape, STEPControl_AsIs)
        buf = io.BytesIO()
        writer.WriteStream(buf)
        buf.seek(0)
        QQ.put(("success", buf.getvalue()))
    except Exception as e:
        # 捕获异常并传递给主进程
        QQ.put(("error", str(e)))

def step_bytes_to_shape(step_bytes):
    reader = STEPControl_Reader()
    buf = io.BytesIO(step_bytes)
    reader.ReadStream(buf)
    reader.TransferRoots()
    return reader.OneShape()

if __name__ == "__main__":
    list_blocks = ...
    result = None
    
    for block in list_blocks:
        QQ = multiprocessing.Queue()
        p1 = multiprocessing.Process(target=cutting_function, args=(block, QQ, # 替换为你的其他参数))
        p1.start()
        
        # 带超时获取队列数据，避免无限阻塞
        try:
            status, data = QQ.get(timeout=60)  # 根据任务时长调整超时时间
            if status == "success":
                result = step_bytes_to_shape(data)
            else:
                print(f"切割失败: {data}")
                # 处理错误，如跳过或重试
        except multiprocessing.queues.Empty:
            print("任务超时，终止进程")
            p1.terminate()
        
        p1.join()

方案3：调整Jupyter多进程启动模式 #

WSL2下Jupyter默认的fork模式可能引发PythonOCC库的资源冲突，改用spawn模式：

import multiprocessing
# 必须放在代码最开始，且在if __name__ == "__main__"块内
if __name__ == "__main__":
    multiprocessing.set_start_method('spawn')
    # 后续的多进程逻辑

注意：spawn模式会重新加载Python环境，所有导入、函数定义需放在if __name__ == "__main__"块内，避免重复执行代码。

关键注意事项 #

• 禁止直接通过队列传递PythonOCC的C++绑定对象，必须转换为可序列化格式（如STEP字节流、二进制数据）。
• Jupyter环境下必须使用if __name__ == "__main__"包裹多进程逻辑，避免子进程重复执行主程序代码。
• 始终添加超时和异常捕获，防止子进程异常导致主程序无限阻塞。

内容的提问来源于stack exchange，提问作者Stefano Pizzamiglio