ProcessPoolExecutor固定参数传递优化：避免大数据重复复制

当需要固定大体积参数a、c，仅让b变化时，没必要重复复制大对象，以下是几种高效实现方式：

1. 用functools.partial绑定固定参数 #

这是最简洁的方案，把固定参数预先绑定到目标函数上，map只需传入变化的b列表，大对象a只会被处理一次。

示例代码：

from concurrent.futures import ProcessPoolExecutor
from functools import partial

def process_data(a, b, c):
    # 这里是你的业务逻辑，比如用大对象a和b、c计算
    return f"处理结果：{a[:10]}... | b={b} | c={c}"

if __name__ == "__main__":
    big_a = "超大字符串数据" * 100000  # 模拟大数据
    fixed_c = "固定配置值"
    b_values = [1, 2, 3, 4, 5]

    # 绑定固定参数a和c，生成新的函数
    bound_process = partial(process_data, big_a, c=fixed_c)

    with ProcessPoolExecutor() as executor:
        # 直接传入变化的b列表即可
        results = executor.map(bound_process, b_values)
        for res in results:
            print(res)

原理：partial会创建一个封装了固定参数的可调用对象，跨进程传递时，大对象a只会被序列化一次（Unix系统下用fork创建子进程的话，甚至会通过写时复制机制共享内存，完全避免复制）。

2. 用进程共享内存处理超大对象 #

如果a是numpy数组、超大列表这类可共享的结构，用multiprocessing的共享内存机制，让所有子进程直接访问同一块内存，彻底杜绝复制开销。

示例代码（用Manager共享大列表）：

from concurrent.futures import ProcessPoolExecutor
from multiprocessing import Manager

def process_data(b, shared_a, c):
    # 直接使用共享内存中的a，无需复制
    return f"处理结果：{shared_a[:10]}... | b={b} | c={c}"

if __name__ == "__main__":
    big_a = ["大数据元素"] * 1000000
    fixed_c = "固定配置值"
    b_values = [1, 2, 3, 4, 5]

    with Manager() as manager:
        # 将大对象存入共享内存
        shared_a = manager.list(big_a)
        with ProcessPoolExecutor() as executor:
            # 传入变化的b，以及共享a和固定c（这里用列表重复只是传递引用，不会复制大对象）
            results = executor.map(process_data, b_values, [shared_a]*len(b_values), [fixed_c]*len(b_values))
            for res in results:
                print(res)

注意：Manager共享对象有轻微性能开销，但对于GB级别的大对象，内存节省的收益远大于这个开销。如果是numpy数组，推荐用multiprocessing.Array结合numpy.frombuffer实现更高效的共享。

3. 用生成器动态生成参数元组 #

如果不想用partial，可以用生成器来逐个生成参数元组，避免提前创建包含重复大对象的列表。

示例代码：

from concurrent.futures import ProcessPoolExecutor

def process_data(a, b, c):
    return f"处理结果：{a[:10]}... | b={b} | c={c}"

if __name__ == "__main__":
    big_a = "超大字符串数据" * 100000
    fixed_c = "固定配置值"
    b_values = [1, 2, 3, 4, 5]

    # 生成器，每次返回一个参数元组，a始终是同一个引用
    params_generator = ((big_a, b, fixed_c) for b in b_values)

    with ProcessPoolExecutor() as executor:
        # 用lambda解包元组参数
        results = executor.map(lambda args: process_data(*args), params_generator)
        for res in results:
            print(res)

原理：生成器不会一次性生成所有参数元组，而是按需生成。在Unix系统下，子进程通过fork继承父进程内存页，只要不修改a，就不会触发复制，内存占用极低。

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