跨进程共享代理实例 object 导致泡菜错误

Question

赏金将在 5 天后到期。 此问题的答案有资格获得+150声望赏金。 lezebulon正在寻找一个规范的答案：

我试图了解我正在做的事情是否应该根据 python 规范/文档（然后它是一个错误）工作，或者不是

我正在尝试在几个进程之间的 python 中实现一个简单的共享 object 系统。 我正在做以下事情：

import os
from multiprocessing.managers import SyncManager

    if __name__ == '__main__':
        manager = SyncManager(authkey=b'test')
        manager.start()
        address = manager.address
        d = manager.dict()
        pickled_dict = d.__reduce__()
        pickled_dict[1][-1]["authkey"] = b"test"
        print(pickled_dict)
        for i in range(1000):
            d[i] = i
    
        child_id = os.fork()
    
        if child_id != 0:
            # in parent, do work on the proxy object forever
            i = 0
            while True:
                d[i%1000] = i%3434
                i += 1
        else:
            # in children
    
            # connect to manager process
            child_manager = SyncManager(address=address, authkey=b'test')
            child_manager.connect()
    
            # rebuild the dictionary proxy
            proxy_obj = pickled_dict[0](*pickled_dict[1])
    
            # read on the proxy object forever
            while True:
                print(list(proxy_obj.values())[:10])

但是在 Python 3.9 上，这会因各种 pickle 错误而失败，例如_pickle.UnpicklingError: invalid load key, '\x0a'.

我在这里做错了什么吗？ AFAIK 应该可以从/向管理器 object 同时读取/写入（多个进程）（仅供参考，我也在 Python 上创建了一个问题： https://github.com/python/cpython/issues/101320但没有答案然而）

Answer 1

我在下面展示的以下代码对您来说可能非常熟悉，所以我告诉您一些您可能已经知道的事情。 但是除了您可能在阅读本文时可能“浪费”了 5 分钟之外，这样做并没有太大的害处。 即便如此，也许你会发现一些有价值的东西。

我真的认为您没有必要使用低级调用__reduce__和fork ，因此此答案不会尝试让这些调用为您工作。 但是，它确实解决了我所理解的您的主要目标，即“...尝试在多个进程之间的 python 中实现一个简单的共享 object 系统”，展示了如何实现多平台解决方案。

以下代码以独立于平台的方式创建一个新进程，并依赖 Python 知道如何序列化代理 object。我还修改了您的代码，使其不会无限期运行：

from multiprocessing.managers import SyncManager
from multiprocessing import Process

def child_process(address, proxy_obj):
    child_manager = SyncManager(address=address, authkey=b'test')
    child_manager.connect()

    print(list(proxy_obj.values())[:10])

if __name__ == '__main__':
    with SyncManager(authkey=b'test') as manager:
        address = manager.address
        # Instead of making 1000 slow calls on a proxy,
        # do this instead:
        d = manager.dict({i: i for i in range(1000)})
        p = Process(target=child_process, args=(address, d))
        p.start()
        p.join()

印刷：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

笔记：

您说，“...应该可以同时（多个进程）从/向管理器对象读取/写入”——事实确实如此。 对代理 object 的每次调用都会导致调用及其 arguments 被序列化并发送到管理器的进程以由线程反序列化和执行。 因此，只要调用是线程安全的，就不会有问题，托管字典的底层实现是标准字典就是这种情况：但是请考虑您的客户端进程正在执行如下代码的情况：

proxy_obj[i] += 1

如果多个进程可能尝试增加同一个值，则需要在multiprocessing.Lock实例的控制下完成，因为增加字典值需要对字典进行两次连续调用，即一次检索当前值一个用增加的值更新字典。 因此，只要您的更新不是原子的，您就需要将更新视为必须序列化执行的关键部分。 例如，

from multiprocessing.managers import SyncManager
from multiprocessing import Process, Lock

def child_process(address, proxy_obj, lock):
    child_manager = SyncManager(address=address, authkey=b'test')
    child_manager.connect()

    for i in range(10):
        with lock:
            proxy_obj[i] += 1

if __name__ == '__main__':
    with SyncManager(authkey=b'test') as manager:
        address = manager.address
        d = manager.dict({i: i for i in range(10)})
        lock = Lock()
        p = Process(target=child_process, args=(address, d, lock))
        p.start()
        for i in range(10):
            with lock:
                d[i] += 1
        p.join()
        print(list(d.values()))

印刷：

[2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

Answer 2

正如评论中已经提到的，问题是父子都使用相同的底层操作系统套接字缓冲区进行通信，因为这是您正在使用的原始 C os.fork的默认行为（仅由定义操作系统，而不是 python），不应在标准 python 代码中使用。 您应该改为使用multiprocessing模块，因为它会进行额外的“清理”以确保不会发生这些错误。

在这种情况下，“清理”只是清除multiprocessing.managers.BaseProxy._address_to_local字典，它在父级中有套接字，它被保存为 python 全局 state 的一部分，它与打开的套接字连接一起继承。

import os
from multiprocessing.managers import SyncManager
import multiprocessing.managers

if __name__ == '__main__':
    manager = SyncManager(authkey=b'test')
    manager.start()
    address = manager.address
    d = manager.dict()
    pickled_dict = d.__reduce__()
    pickled_dict[1][-1]["authkey"] = b"test"
    print(pickled_dict)
    for i in range(1000):
        d[i] = i

    child_id = os.fork()

    if child_id != 0:
        # in parent, do work on the proxy object forever
        i = 0
        while True:
            d[i % 1000] = i % 3434
            i += 1
    else:
        # in children
        multiprocessing.managers._address_to_local.clear()

        # rebuild the dictionary proxy
        proxy_obj = pickled_dict[0](*pickled_dict[1])

        # read on the proxy object forever
        while True:
            print(list(proxy_obj.values())[:10])

请注意，当孩子试图终止时，这将引发另一个错误，因为它将尝试加入它也继承的manager ，因为它的引用没有被清理，但这不会使您的应用程序崩溃，只要有一个内置模块，可以为您完成所有这些……哦，对了，有。

python os模块实现被定义为依赖于os，它只提供OS功能的包装器，它不需要其他模块的安全性和可移植性。