python - 子类化 multiprocessing.managers.BaseProxy

Question

我在尝试实现新的 defaultdict 代理对象时遇到了一些问题。 documentation有点害怕，所以我不确定如何正确地解决这个问题。

我想将 defaultdict 添加到 Manager 实例可用的类型列表中。您不能在 multiprocessing.Manager 上使用 Manager.register 方法，所以我从 multiprocessing.mangers.BaseManager 中创建了自己的 stub 管理器>

class Manager(BaseManager):
    pass

然后我创建了 multiprocessing.managers.BaseProxy 的子类来容纳 defaultdict(我最初尝试使用另一个 stub 来继承 defaultdict 和 BaseProxy 但这似乎不起作用。这是我目前拥有的:

class ProxyDefaultDict(BaseProxy):
    def __init__(self, default_factory=None, *args, **kwargs):
        self.__data = defaultdict(default_factory)
        super().__init__(*args, **kwargs)

    def _callmethod(self, methodname, args=(), kwds={}):
        return getattr(self.__data, methodname)(*args, **kwds)

    def _getvalue(self):
        return self.__data.copy()

    def __repr__(self):
        return self.__data.__repr__()

    def __str__(self):
        return self.__data.__str__()

Manager.register('defaultdict', ProxyDefaultDict)

最终目标是拥有一个共享字典，它可以跨进程和线程安全地共享键控锁。这是我如何初始化它的示例:

if __name__ == '__main__':
    m = Manager()
    d = m.defaultdict(m.Lock)
    with d['named_lock']:
        print('holding the lock')

但是，我遇到了一些问题:

1. BaseManager 的子类似乎只能通过上下文管理器初始化，即 with Manager() as m。在这种情况下我会使用 m = Manager() - 因为 multiprocessing.Manager 允许。这不是世界末日，但更好奇的是为什么会这样，如果这是我做错事情的迹象。

2. 子类化 multiprocessing.managers.BaseManager 也意味着您失去了 multiprocessing.Manager 的默认注册值。在这种情况下，我需要为我的经理重新注册一个 ProxyLock(我也不确定这样做的预期方式)。直接子类化 multiprocessing.Manager 是否安全。

3. 最后，我的 ProxyDefaultDict 似乎不允许我完全覆盖它的 __init__。我厌倦了在子类化时不调用 BaseProxy.__init__。问题是 BaseProxy 也接受位置参数。我想解决这个问题的方法是使 default_factory 参数仅成为键控参数，但这会将预期的接口(interface)更改为 defaultdict 并让我假设我在这里做错了什么再次。 Manager.Lock 等其他类型似乎能够接受位置参数。

感谢您的帮助。

Answer 1

查看源代码后，对其稍加修改就可以毫无问题地获得 defaultdict 类型的代理(基于内置 DictProxy 的创建方式)。

from collections import defaultdict

from multiprocessing.managers import MakeProxyType, SyncManager

DefaultDictProxy = MakeProxyType("DefaultDictProxy", [
    '__contains__', '__delitem__', '__getitem__', '__len__',
    '__setitem__', 'clear', 'copy', 'default_factory', 'fromkeys',
    'get', 'items', 'keys', 'pop', 'popitem', 'setdefault',
    'update', 'values'])

SyncManager.register("defaultdict", defaultdict, DefaultDictProxy)
# Can also create your own Manager here, just using built in for simplicity

if __name__ == '__main__':
    with SyncManager() as sm:
        dd = sm.defaultdict(list)
        print(dd['a'])
        # []

我个人觉得使用已经提供的工具很方便，甚至不需要担心如何自己对其进行子类化。

但是，我认为这不会允许您创建您正在寻找的默认锁方案。多进程锁被设计成只能继承，一般锁不能被 pickle，这是通过代理传输的数据类型的要求。示例:

    from multiprocessing import Lock

    m = SyncManager()
    m.start()
    d = m.defaultdict(Lock)
    print(d['named_lock'])
    m.shutdown()

会引发运行时错误:

RuntimeError: Lock objects should only be shared between processes through inheritance