Python 子类化 multiprocessing.Lock

Question

我试图理解为什么 python 不能编译以下类。

class SharedResource(multiprocessing.Lock):
    def __init__(self, blocking=True, timeout=-1):
        # super().__init__(blocking=True, timeout=-1)
        self.blocking = blocking
        self.timeout = timeout
        self.data = {}

类型错误：方法需要 2 个参数，得到 3 个

我将 Lock 子类化的原因是我的目标是创建一个共享资源列表，该列表一次只能由 on 进程使用。

这个概念最终会出现在 Flash 应用程序中，其中请求不应该同时使用资源

RuntimeError：锁对象只能通过继承在进程之间共享

class SharedResource():
    def __init__(self, id, model):
        '''
        id: mode id
        model: Keras Model only one worker at a time can call predict
        '''  
        self.mutex = Lock()
        self.id = id
        self.model = model

manager = Manager()
shared_list = manager.list() # a List of models
shared_list.append(SharedResource())

def worker1(l):
    ...read some data
    while True:
        resource = l[0]
        with m:
            resource['model'].predict(...some data)
        time.sleep(60)  


if __name__ == "__main__":
   processes = [ Process(target=worker1, args=[shared_list])]
   for p in processes:
       p.start()
   for p in processes:
       p.join()

Answer 1

您收到此错误的原因是multiprocessing.Lock实际上是一个函数。

在.../multiprocessing/context.py有这些行：

def Lock(self):
    '''Returns a non-recursive lock object'''
    from .synchronize import Lock
    return Lock(ctx=self.get_context())

这在未来可能会发生变化，因此您可以通过执行以下操作在您的 python 版本上验证这一点：

import multiprocessing
print(type(multiprocessing.Lock))

要真正继承Lock你需要做这样的事情：

from multiprocessing import synchronize
from multiprocessing.synchronize import Lock

# Since Lock is now a class, this should work:
class SharedResource(Lock):
    pass

我不认为这种方法是一个“好的”解决方案，但如果您确实需要子类Lock ，它应该可以解决您的问题。 对试图避免被子类化的事物进行子类化通常不是一个好主意，但有时它可能是必要的。 如果您可以以不同的方式解决问题，您可能需要考虑。