使用Multiprocessing时采用全局变量是否高效？附代码场景解析

兄弟，直接给你结论：在multiprocessing多进程开发里用全局变量，完全没有执行效率优势，搞不好还会拖慢你的程序、浪费内存。为啥？听我给你拆解清楚，再结合你的代码给点优化建议。

为啥全局变量在多进程里不高效？ #

• 内存复制开销巨大：multiprocessing的每个子进程都有独立的内存空间，主进程里的全局变量会被完整复制一份到每个子进程中。就像你代码里的slave DataFrame，如果它的数据量很大（比如几G），那开8个进程就意味着内存里要存8份一模一样的slave，这复制的时间和内存占用直接拉垮性能。
• 无共享内存特性：和线程不同，多进程之间默认不共享内存，全局变量根本没法实现“一处修改处处生效”，反而只是多个独立副本，完全达不到你想复用资源的目的。

针对你的代码的优化方案 #

你的代码里helper函数依赖全局的slave，这不是最优写法。给你两种更高效的替代思路：

思路1：用Pool的initializer初始化子进程资源 #

如果slave是需要重复使用的大对象，可以让每个子进程启动时加载一次（而不是主进程复制多次），用Pool的initializer参数来实现：

from multiprocessing import Pool, cpu_count
import pandas as pd
from datetime import datetime

# 子进程全局变量，用于存储slave数据
slave = None

def init_worker(slave_df):
    """初始化子进程的共享资源"""
    global slave
    slave = slave_df

def helper(master_row):
    """子进程执行的任务"""
    max_idx = master_row['key']
    min_idx = master_row['key'] - 1  # 这里根据你的业务逻辑调整
    return slave.iloc[min_idx:max_idx, ]

if __name__ == '__main__':
    master = pd.DataFrame({'key': [1,2,3,4,5,6,7,8,9,10]})
    slave = pd.DataFrame({
        'key': [1,2,3,4,5,6,7,8,9,10],
        'value': ['a','b','c','d','e','f','g','h','i','j']
    })

    start = datetime.now()
    # 初始化进程池，每个子进程都会调用init_worker加载slave
    with Pool(cpu_count(), initializer=init_worker, initargs=(slave,)) as pool:
        results = pool.map(helper, [row for _, row in master.iterrows()])
    end = datetime.now()
    print(f"执行耗时: {end - start}")

这种方式的好处是，每个子进程只加载一次slave，避免了主进程向多个子进程重复复制大对象的开销。

思路2：拆分大对象，分块传递 #

如果slave可以按业务逻辑拆分，直接把拆分后的小块作为参数传给子进程，完全不需要全局变量：

from multiprocessing import Pool, cpu_count
import pandas as pd
import numpy as np
from datetime import datetime

def helper(args):
    """参数是拆分后的slave块和对应的master行"""
    slave_chunk, master_row = args
    max_idx = master_row['key']
    min_idx = master_row['key'] - 1
    return slave_chunk.iloc[min_idx:max_idx, ]

if __name__ == '__main__':
    master = pd.DataFrame({'key': [1,2,3,4,5,6,7,8,9,10]})
    slave = pd.DataFrame({
        'key': [1,2,3,4,5,6,7,8,9,10],
        'value': ['a','b','c','d','e','f','g','h','i','j']
    })

    # 按进程数拆分slave
    cpu_num = cpu_count()
    slave_chunks = np.array_split(slave, cpu_num)
    # 把每个master行和对应的chunk配对
    task_args = [(slave_chunks[i%cpu_num], row) for i, (_, row) in enumerate(master.iterrows())]

    start = datetime.now()
    with Pool(cpu_num) as pool:
        results = pool.map(helper, task_args)
    end = datetime.now()
    print(f"执行耗时: {end - start}")

这种方式让每个子进程只处理一部分数据，内存占用更低，也避免了全局变量的复制问题。

额外提醒 #

如果你的slave是超大数据集（比如几十G），可以考虑用Python 3.8+的multiprocessing.shared_memory，让多个进程共享同一块内存区域，彻底避免复制开销，pandas 1.3版本以上也支持基于共享内存的DataFrame操作。

内容的提问来源于stack exchange，提问作者ℕʘʘḆḽḘ