Python Multiprocessing实现多层图像合并提速问题求助

我花了数小时在Stack Overflow、Google检索相关解决方案，始终接近正确结果但未能彻底解决问题。我感觉问题出在create_files函数的简单逻辑处，但一直没能定位根因。

我正在优化一款基于Pillow开发的程序：程序从编号文件夹中随机选取图像，按照透明度规则逐层堆叠合成。当文件夹数量达到18个、每个文件夹包含约20张图像时，在我的M1 MacBook Pro上单张图像合成耗时约2秒，运行速度较慢。我尝试引入multiprocessing多进程机制提升运行速度，但可能因为现有代码过度依赖for循环迭代变量，调用pool.map时始终出现各类报错，无法正常运行。
以下是相关功能的代码片段，部分函数调用的变量为文件夹路径，或存储所有图像路径的数组（image1对应索引[0]、image2对应索引[1]，以此类推）：

def save_file(img, counter):
    if not os.path.exists(f"{output_folder}"):
        os.makedirs(f"{output_folder}")
    img.save(f"{output_folder}/file_{counter}.png")


def create_composite(layer_count, img):
    image_size = Image.open(image_paths[0][0])
    composite_img = Image.new("RGBA", image_size.size)
    composite_img = merge_images(layer_count, img, composite_img)
    return composite_img


def merge_images(layer_count, img, composite_img):
    for i in range(layer_count):
        next_img = Image.open(img[i])
        composite_img = Image.alpha_composite(composite_img, next_img)
    return composite_img


def randomise_layers(layer_count):
    # Creates an array with randomised files for each layer and checks for exceptions.
    image_stack = []
    for i in range(layer_count):
        # Checks if there are any image conflicts and adds them to the stack.
        image_stack.append(check_exception(i))
    return image_stack


def check_exception(index):
    # Checks if any of the layers have a known exception with another layer
    temp_file_path = file_paths(index)
    if is_exception(temp_file_path):
        check_exception(index)
    else:
        return temp_file_path


def is_exception(file_path):
    # Gets layer exceptions from file
    return False


def create_files(iterations):
    for i in range(iterations):
        save_file(create_composite(layer_count, randomise_layers(layer_count)), i)
        if iterations < 10:
            print(f"File {i+1} created.")

if __name__ == "__main__":
    iterations = 5
    create_files(iterations)

多进程运行报错、速度不达预期核心有3个问题：

• macOS默认用spawn模式启动子进程，不会自动继承主进程的全局变量，原代码中layer_count、image_paths、output_folder均为全局依赖，子进程调用时直接触发未定义错误。
• 原代码逻辑耦合度高，单循环内同时完成随机选层、图像合成、文件保存操作，不符合pool.map对任务函数「单参数输入、无外部依赖」的要求。
• 原有逻辑自带bug：check_exception递归重选文件时没有加return，命中异常规则时会返回None，后续合成操作直接报错。另外每次合成前都重复打开第一张图读取尺寸，存在无意义的IO开销。

按以下步骤调整即可正常启用多进程加速：

1. 提前在主进程完成输出目录创建、基础画布尺寸读取这类一次性操作，不要放到子进程重复执行。
2. 修复check_exception的递归返回bug。
3. 把单张图像的全流程处理（随机选层、合成、保存）拆成独立的纯函数，所有依赖参数通过入参传入，不依赖全局变量。
4. 提前组装所有任务的参数列表，传入pool.map执行，进程数设置为CPU物理核心数即可，开过多进程反而会因为IO调度竞争降低速度。

重构后的可运行代码如下：

import os
import multiprocessing
from PIL import Image

# 提前定义全局配置，主进程初始化后通过参数传给子进程，不要在子进程直接读取
LAYER_COUNT = 18
IMAGE_PATHS = []  # 替换为原逻辑中存储各层图片路径的数组
OUTPUT_FOLDER = "./output"
ITERATIONS = 5

def file_paths(index):
    # 替换为原有的路径选择逻辑
    return IMAGE_PATHS[index][0]

def is_exception(file_path):
    # 替换为原有的异常校验逻辑
    return False

def check_exception(index):
    temp_file_path = file_paths(index)
    if is_exception(temp_file_path):
        # 递归调用必须加return，否则返回值会丢失
        return check_exception(index)
    return temp_file_path

def randomise_layers(layer_count):
    image_stack = []
    for i in range(layer_count):
        image_stack.append(check_exception(i))
    return image_stack

def merge_images(layer_count, img_paths, base_size):
    composite_img = Image.new("RGBA", base_size)
    for path in img_paths:
        next_img = Image.open(path)
        composite_img = Image.alpha_composite(composite_img, next_img)
    return composite_img

def process_single_image(task_params):
    """单张图处理任务，所有参数通过入参传入，无全局依赖，适配多进程调用"""
    counter, layer_count, base_size, output_folder = task_params
    # 随机选层
    layer_paths = randomise_layers(layer_count)
    # 合成图像
    composite = merge_images(layer_count, layer_paths, base_size)
    # 保存文件
    composite.save(f"{output_folder}/file_{counter}.png")
    print(f"File {counter+1} created.")
    return counter

if __name__ == "__main__":
    # 主进程提前完成一次性初始化
    os.makedirs(OUTPUT_FOLDER, exist_ok=True)
    # 提前读取基础画布尺寸，避免每次合成都重复打开文件
    base_img = Image.open(IMAGE_PATHS[0][0])
    base_size = base_img.size
    base_img.close()
    
    # 组装所有任务的参数列表
    task_list = [
        (i, LAYER_COUNT, base_size, OUTPUT_FOLDER)
        for i in range(ITERATIONS)
    ]
    
    # 启动多进程，M1芯片直接用os.cpu_count()获取最优进程数
    with multiprocessing.Pool(processes=os.cpu_count()) as pool:
        pool.map(process_single_image, task_list)

• 如果单张图合成耗时还是偏高，可以提前把所有图层的Image对象在主进程加载好传入子进程，避免每个子进程重复做文件IO，注意控制内存占用即可。
• 确认安装的Pillow是ARM原生版本，Rosetta转译的版本在M1芯片上多进程调度会有30%左右的性能损耗。
• 如果需要展示进度，不要在子进程里直接print，改用pool.imap配合进度条工具可以实现更稳定的进度展示。

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