Python子类化多处理。锁定

Python subclassing multiprocessing.Lock(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子类化多处理。锁定的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持编程学习网！