Python使用multiprocessing.Pool出现Lock跨进程共享错误如何解决

你遇到的报错核心有两个底层逻辑：

1. multiprocessing.Pool 在Windows/macOS默认的spawn启动模式下，会对传递给子进程的所有对象执行pickle序列化操作，而multiprocessing.Lock、打开的文件句柄属于不可序列化的对象，无法通过序列化传递给子进程。
2. 调用pool.map(self.function, range(10000))的时候，会把整个类实例self序列化后传给子进程，而self里包含了Lock和打开的文件两个不可序列化的属性，直接触发报错。

这里提供两种可跨平台的常用实现方案：

方案一：提前读取文件内容到内存，消除共享资源依赖 #

如果test.txt文件大小可控，直接提前把所有内容读入内存，完全不需要共享Lock和文件句柄，代码实现最简单：

from multiprocessing import Pool

class A:
    def __init__(self):
        # 提前把所有行读入内存，后续直接索引取即可
        with open('test.txt', 'r') as f:
            self.lines = f.readlines()
    def function(self, i):
        # 直接取对应索引的行，不需要加锁
        return self.lines[i] if i < len(self.lines) else None
    def anotherfunction(self):
        pool = Pool()
        # 最多取文件实际行数的数量，避免越界
        results = pool.map(self.function, range(min(10000, len(self.lines))))
        pool.close()
        pool.join()
        return results

该方案优势是逻辑简单，没有进程间同步开销，运行效率最高。

方案二：使用Pool的initializer传递共享资源，适配大文件场景 #

如果文件太大无法全部读入内存，就通过Pool的初始化机制把共享资源通过继承传给子进程，不需要序列化：

from multiprocessing import Lock, Pool

# 全局变量存储子进程继承到的共享资源
process_lock = None
process_file = None

def init_process(lock, file_path):
    global process_lock, process_file
    process_lock = lock
    # 每个子进程单独打开文件，避免共享文件句柄的指针冲突
    process_file = open(file_path, 'r')

class A:
    def __init__(self, file_path='test.txt'):
        self.file_path = file_path
        self.lock = Lock()
    def function(self, i):
        process_lock.acquire()
        line = process_file.readline()
        process_lock.release()
        return line
    def anotherfunction(self):
        # 创建Pool的时候把锁和文件路径通过初始化参数传给子进程
        pool = Pool(initializer=init_process, initargs=(self.lock, self.file_path))
        results = pool.map(self.function, range(10000))
        pool.close()
        pool.join()
        return results

该方案优势是不需要把全部文件读入内存，支持超大文件处理。

• 不要把不可序列化的对象（Lock、文件句柄、套接字等）作为类属性传递给Pool的任务函数，避免序列化失败
• 多进程场景下尽量避免跨进程共享可变资源，能提前拆分任务独立处理的优先拆分，减少同步锁带来的性能损耗
• 如果确实需要在类实例里持有可跨进程传递的锁，可以用from multiprocessing import Manager，然后初始化self.lock = Manager().Lock()，这种锁支持pickle序列化，可以直接传递给子进程，但同步开销比原生Lock高，不推荐高并发场景使用

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