Python子类化多处理。锁定

问题描述

我正在尝试了解为什么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 = {}

TypeError：方法需要%2个参数，但得到%3

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

此概念最终将出现在Flash应用程序中，在该应用程序中，请求不应同时使用资源

运行错误：锁定对象只能通过继承在进程之间共享

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()

推荐答案

您收到此错误的原因是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，它应该可以解决您的问题。对试图避免被子类化的对象进行子类化通常不是一个好主意，但有时它可能是必要的。如果您可以用不同的方法解决问题，您可能需要考虑一下。

这篇关于Python子类化多处理。锁定的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！