Python多进程池序列化问题排查：非可Pickle对象传递困境

方案1：利用Unix系统的fork进程模式（仅适用于Linux/macOS） #

fork模式下，子进程会直接复制父进程的内存空间，无需序列化传递对象。你可以在父进程中一次性初始化g_ifc和g_oalist，子进程通过继承直接访问这些全局变量，完全避开Pickle问题。

代码示例：

import multiprocessing
import ifcopenshell

# 全局变量，父进程初始化后子进程直接继承
g_ifc = None
g_oalist = None

def process_scrow(scrow_item):
    # 直接使用继承的全局资源
    # 替换为你的实际业务逻辑
    result = scrow_item 
    return result

if __name__ == '__main__':
    # 父进程中仅执行一次高消耗的ifc文件打开和g_oalist生成
    ifc_file_path = "your_target.ifc"
    g_ifc = ifcopenshell.open(ifc_file_path)
    g_oalist = [obj for obj in g_ifc.by_type("IfcWall")]  # 替换为你的衍生逻辑
    
    scrow_list = [1, 2, 3, 4]  # 替换为你的实际scrow迭代列表
    
    # 默认fork模式创建进程池，无需额外配置
    with multiprocessing.Pool() as pool:
        results = pool.map(process_scrow, scrow_list)
    
    # 处理结果
    for res in results:
        print(res)

优缺点：

• 优点：资源初始化仅一次，性能最优，代码简洁
• 缺点：仅支持Unix类系统，Windows系统默认使用spawn模式无法生效

方案2：用进程池initializer初始化子进程资源（跨平台） #

如果需要兼容Windows系统，可以利用Pool的initializer参数，让每个子进程在启动时自行初始化g_ifc和g_oalist。虽然每个子进程都会执行一次初始化，但进程池的进程数是固定的（比如CPU核心数），远少于scrow迭代次数，不会抵消多进程优势。

代码示例：

import multiprocessing
import ifcopenshell

# 子进程内的全局变量
g_ifc = None
g_oalist = None

def init_worker(ifc_file_path):
    """子进程启动时执行的初始化函数"""
    global g_ifc, g_oalist
    # 每个子进程仅执行一次初始化
    g_ifc = ifcopenshell.open(ifc_file_path)
    g_oalist = [obj for obj in g_ifc.by_type("IfcWall")]  # 替换为你的衍生逻辑

def process_scrow(scrow_item):
    # 直接使用子进程内初始化的全局资源
    result = scrow_item  # 替换为实际处理逻辑
    return result

if __name__ == '__main__':
    ifc_file_path = "your_target.ifc"
    scrow_list = [1, 2, 3, 4]  # 替换为你的实际scrow迭代列表
    
    # 按CPU核心数设定进程池大小
    pool_size = multiprocessing.cpu_count()
    with multiprocessing.Pool(pool_size, initializer=init_worker, initargs=(ifc_file_path,)) as pool:
        results = pool.map(process_scrow, scrow_list)
    
    # 处理结果
    for res in results:
        print(res)

优缺点：

• 优点：跨平台支持，避免Pickle序列化问题
• 缺点：每个子进程都要执行一次资源初始化，总初始化次数等于进程池大小

方案3：手动管理进程+队列（高度可控） #

如果需要更精细的进程资源控制，可以手动创建进程，每个进程持有一份g_ifc和g_oalist，通过队列传递任务和结果。这种方式完全避开进程池的序列化限制，资源复用效率最高。

代码示例：

import multiprocessing
import ifcopenshell

def worker(task_queue, result_queue, ifc_file_path):
    """工作进程逻辑：初始化资源后循环处理任务"""
    # 仅初始化一次资源
    g_ifc = ifcopenshell.open(ifc_file_path)
    g_oalist = [obj for obj in g_ifc.by_type("IfcWall")]  # 替换为你的衍生逻辑
    
    while True:
        scrow_item = task_queue.get()
        if scrow_item is None:  # 接收结束信号，退出循环
            break
        # 处理任务
        result = scrow_item  # 替换为实际处理逻辑
        result_queue.put(result)

if __name__ == '__main__':
    ifc_file_path = "your_target.ifc"
    scrow_list = [1, 2, 3, 4]  # 替换为你的实际scrow迭代列表
    
    num_workers = multiprocessing.cpu_count()
    task_queue = multiprocessing.Queue()
    result_queue = multiprocessing.Queue()
    
    # 启动工作进程
    workers = []
    for _ in range(num_workers):
        p = multiprocessing.Process(target=worker, args=(task_queue, result_queue, ifc_file_path))
        p.start()
        workers.append(p)
    
    # 向队列中添加任务
    for item in scrow_list:
        task_queue.put(item)
    
    # 向每个工作进程发送结束信号
    for _ in range(num_workers):
        task_queue.put(None)
    
    # 收集结果
    results = []
    for _ in range(len(scrow_list)):
        results.append(result_queue.get())
    
    # 等待所有工作进程结束
    for p in workers:
        p.join()
    
    # 处理结果
    for res in results:
        print(res)

优缺点：

• 优点：完全可控，资源复用效率高，无序列化问题
• 缺点：代码复杂度较高，需要手动管理队列和进程生命周期

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