子类化 multiprocessing.managers.BaseProxy

我在尝试实施新的方法时遇到了一些麻烦defaultdict代理对象。这文档 https://docs.python.org/3/library/multiprocessing.html#multiprocessing.managers.BaseProxy有点害怕，所以我不知道如何正确地解决这个问题。

我想添加一个defaultdict到可用的类型列表Manager实例。您不能使用Manager.register股票方法multiprocessing.Manager所以我从以下位置创建了自己的存根管理器multiprocessing.mangers.BaseManager

class Manager(BaseManager):
    pass

然后我创建了我的子类multiprocessing.managers.BaseProxy容纳defaultdict（我最初尝试使用花药存根，它将对两者进行子类化defaultdict and 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_factoryargument 仅是一个键控参数，但这会将预期的接口更改为defaultdict让我假设我又在这里做错了什么。其他类型如Manager.Lock似乎能够接受位置参数。

谢谢你的帮助。

查看源代码后，对其进行一些修改即可让我毫无问题地获得 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'])
        # []

就我个人而言，我发现通过使用已经提供的工具很方便，甚至不需要担心如何自己对其进行子类化。

但是，我认为这不会允许您创建您正在寻找的默认锁定方案。多处理锁被设计为仅继承，并且通常锁不能被腌制，这是通过代理传输的数据类型的要求。例子：

    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