为什么要多处理不通过其他进程阻止对象使用的锁？

Question

以下代码是一家商店，该商店有5个项目和3个客户要求一项。

import multiprocessing as mp
 
class Shop:
    def __init__(self, stock=5):
        self.stock = stock

    def get_item(self, l, x):
        l.acquire()
        if self.stock >= x:
            self.stock -= x
            print(f"{self.stock} = remaining")
        l.release()

if __name__ == "__main__":
    l = mp.Lock()
    obj = Shop()

    p1 = mp.Process(target=obj.get_item, args=(l, 1))
    p2 = mp.Process(target=obj.get_item, args=(l, 1))
    p3 = mp.Process(target=obj.get_item, args=(l, 1))

    p1.start()
    p2.start()
    p3.start()

    p1.join()
    p2.join()
    p3.join()

    print("Final: ", obj.stock)

但是，我得到的输出如下

4 = remaining
4 = remaining
4 = remaining
Final:  5

，因为我使用锁定我期望它会

4 = remaining
3 = remaining
2 = remaining
Final:  2

质疑：如何仅使用锁来实现上述输出（并且没有过程通信，即没有管道/队列）？

Answer 1

此代码无法正常工作的原因是，由于多处理没有与子流程共享其状态。这意味着您启动的每个过程，p1，p2和p3，获取class对象的副本shop shop < /代码>。它不是同一对象。 有两种方法可以解决此问题，与进程共享实例属性，或共享整个对象本身。如果商店对象拥有需要在流程之间共享的其他数据，则第二种方法可能会更好。

方法1 ：

仅共享库存实例变量的值，您可以使用

shared_int = multiprocessing.Value('i', 5)
print(f'Value is {shared_int.value}')  # 5 

适应您的用例，代码将成为：

import multiprocessing


class Shop:
    def __init__(self, stock=5):
        self.stock = multiprocessing.Value('i', stock)


    def get_item(self, l, x):
        l.acquire()
        if self.stock.value >= x:
            self.stock.value -= x
            print(f"{self.stock.value} = remaining")
        l.release()


if __name__ == "__main__":
    l = multiprocessing.Lock()
    obj = Shop()

    p1 = multiprocessing.Process(target=obj.get_item, args=(l, 1))
    p2 = multiprocessing.Process(target=obj.get_item, args=(l, 1))
    p3 = multiprocessing.Process(target=obj.get_item, args=(l, 1))

    p1.start()
    p2.start()
    p3.start()

    p1.join()
    p2.join()
    p3.join()

    print("Final: ", obj.stock.value)

output> output>

4 = remaining
3 = remaining
2 = remaining
Final:  2

方法2

共享整个复杂对象是一个更具参与的过程。我最近有回答 详细介绍了有关共享复杂对象的类似问题（例如，在这种情况下是类商店的对象），还介绍了下面提供的代码背后的推理。我建议您对其进行阅读，因为它可以更详细地说明底部提供的代码背后的逻辑。此用例的唯一主要区别是您要使用 supperrocess ，多处理，而不是多处理。该库与内置的多处理相同，除了它提供了我们需要的更好的腌制支持。

基本上，您将需要使用 nofollow noreferrer“> supperrocessing.managers.managers ，以及适合访问该州的代理。 objproxy在下面的代码中提供的代理是共享名称空间和实例方法的代理（除了受保护/私有属性外）。一旦拥有这些，您只需要使用经理和代理创建类shop的对象即可。这是使用新添加的创建类shop> shop的方法完成的。这是一个类构造函数，shop> shop的所有对象应仅使用此方法创建，而不是直接调用构造函数。完整代码：

import multiprocess
from multiprocess import Manager, Process
from multiprocess.managers import NamespaceProxy, BaseManager
import types


class ObjProxy(NamespaceProxy):
    """Returns a proxy instance for any user defined data-type. The proxy instance will have the namespace and
    functions of the data-type (except private/protected callables/attributes). Furthermore, the proxy will be
    pickable and can its state can be shared among different processes. """

    def __getattr__(self, name):
        result = super().__getattr__(name)
        if isinstance(result, types.MethodType):
            def wrapper(*args, **kwargs):
                return self._callmethod(name, args, kwargs)
            return wrapper
        return result


class Shop:

    def __init__(self, stock=5):
        self.stock = stock

    @classmethod
    def create(cls, *args, **kwargs):

        # Register class
        class_str = cls.__name__
        BaseManager.register(class_str, cls, ObjProxy, exposed=tuple(dir(cls)))

        # Start a manager process
        manager = BaseManager()
        manager.start()

        # Create and return this proxy instance. Using this proxy allows sharing of state between processes.
        inst = eval("manager.{}(*args, **kwargs)".format(class_str))
        return inst

    def get_item(self, l, x):
        with l:
            if self.stock >= x:
                self.stock -= x
                print(f"{self.stock} = remaining")

    def k(self, l, n):
        pass


if __name__ == "__main__":
    manager = Manager()
    l = manager.Lock()
    obj = Shop.create()
    p1 = Process(target=obj.get_item, args=(l, 1, ))
    p2 = Process(target=obj.get_item, args=(l, 1, ))
    p3 = Process(target=obj.get_item, args=(l, 1, ))

    p1.start()
    p2.start()
    p3.start()

    p1.join()
    p2.join()
    p3.join()

    print("Final: ", obj.stock) 

输出

4 = remaining
3 = remaining
2 = remaining
Final:  2

注意：这两行的说明：

manager = Manager()
l = manager.Lock()

我们不需要在您的锁之前为锁创建经理（随后是代理）的原因示例概述在这里。它之所以不使用上述代码而不创建代理的原因是因为我们不再在主过程中创建进程，并且在当前过程中不存在锁定（因为为我们的复杂对象创建管理器为了共享其状态，产生了自己的服务器流程）