你碰到的核心问题是多进程之间的内存是相互隔离的——每个子进程都有自己独立的内存空间，主进程里的added列表和子进程里新建的added完全是两个不相关的对象，子进程没法直接访问或修改主进程的列表。要实现你想要的「在循环每一步把当前列表内容传入函数」的效果，得调整参数传递逻辑，同时适配多进程的内存特性。

具体修改方案 #

咱们可以做这几个关键调整：

1. 给foo函数加个参数，让它能接收主进程传递过来的当前added列表副本；
2. 在主进程循环里，把待处理元素和当前added打包成参数，传给多进程任务；
3. 正确收集子进程的返回结果，合并到主进程的added里（别直接取迭代器的[-1]，那不是正确用法）。

下面是修改后的可运行代码示例：

from multiprocessing import Pool

def foo(args):
    i, current_added = args
    # 这里可以直接使用传入的current_added做业务逻辑
    # 比如判断值是否已存在、基于现有列表计算新值等
    new_value = i * 2  # 替换成你的实际业务逻辑
    return new_value

if __name__ == '__main__':
    c = [1, 2, 3, 4, 5, 6, 7, 8]  # 假设这是你的原始数据集c
    added = []
    h = 0
    # 把进程池创建移到循环外，避免反复创建销毁进程，提升效率
    pool = Pool(4)

    while len(added) < len(c):
        # 筛选出还没处理的元素
        remaining_items = [item for item in c if item not in added]
        # 打包参数：每个待处理元素 + 当前added的副本（避免子进程意外修改主进程数据）
        tasks = [(item, added.copy()) for item in remaining_items]
        
        # 提交任务并遍历结果
        results = pool.imap_unordered(foo, tasks)
        for res in results:
            added.append(res)
        
        h += 1
        print(f"循环次数h={h}, 当前added长度: {len(added)}")
    
    pool.close()
    pool.join()
    print("最终added列表:", added)

关键细节说明 #

• 进程池复用：别在循环里反复创建Pool，进程的创建销毁开销很大，放在循环外复用能大幅提升性能；
• 参数打包：因为imap_unordered只能传递单个参数，所以我们把i和current_added打包成元组，让foo接收后再解包；
• 副本传递：我们传的是added.copy()，也就是列表的副本——子进程拿到的是独立副本，修改它不会影响主进程的added，避免了并发修改的风险；
• 结果收集：imap_unordered返回的是迭代器，必须遍历它才能获取所有子进程的返回值，再逐个添加到主进程的added里。

额外优化（针对大型列表） #

如果你的added列表很大，每次传递副本会有性能开销，可以用共享内存对象来替代普通列表，不过要注意加锁保证并发安全：

from multiprocessing import Pool, Manager

def foo(args):
    i, shared_added, lock = args
    # 用锁保证修改共享列表时的线程安全
    with lock:
        if i not in shared_added:
            new_value = i * 2
            shared_added.append(new_value)
    return new_value

if __name__ == '__main__':
    c = [1, 2, 3, 4, 5, 6, 7, 8]
    manager = Manager()
    # 创建可跨进程共享的列表
    added = manager.list()
    # 创建锁，避免多进程同时修改共享列表
    lock = manager.Lock()
    h = 0
    pool = Pool(4)

    while len(added) < len(c):
        remaining_items = [item for item in c if item not in added]
        tasks = [(item, added, lock) for item in remaining_items]
        results = pool.imap_unordered(foo, tasks)
        # 这里可以不用处理结果，因为子进程已经直接修改了共享列表
        for _ in results:
            pass
        
        h += 1
        print(f"循环次数h={h}, 当前added长度: {len(added)}")
    
    pool.close()
    pool.join()
    print("最终added列表:", list(added))

这种方式适合大型数据集，避免了反复传递列表副本的开销，但一定要用锁来保护共享资源，不然会出现数据混乱的问题。

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