样本1

Question

这可能是一个基本问题，但我不熟悉Python中的线程编程，并不完全确定正确的做法是什么。

我应该创建一个单独的锁对象（全局还是被传递）并在我需要锁定的任何地方使用它？或者，我应该在每个将要使用它们的类中创建多个锁实例。拿这两个基本的代码样本，哪个方向最好去？主要区别在于第二个类A和B都使用单个锁实例，而第一个使用多个实例。

样本1

class A():
    def __init__(self, theList):
        self.theList = theList
        self.lock = threading.Lock()

    def poll(self):
        while True:
            # do some stuff that eventually needs to work with theList
            self.lock.acquire()
            try:
                self.theList.append(something)
            finally:
                self.lock.release()





class B(threading.Thread):
    def __init__(self,theList):
        self.theList = theList
        self.lock = threading.Lock()
        self.start()


    def run(self):
        while True:
            # do some stuff that eventually needs to work with theList
            self.lock.acquire()
            try:
                self.theList.remove(something)
            finally:
                self.lock.release()



if __name__ == "__main__":
    aList = []
    for x in range(10):
        B(aList)

    A(aList).poll()

样本2

class A():
    def __init__(self, theList,lock):
        self.theList = theList
        self.lock = lock

    def poll(self):
        while True:
            # do some stuff that eventually needs to work with theList
            self.lock.acquire()
            try:
                self.theList.append(something)
            finally:
                self.lock.release()



class B(threading.Thread):
    def __init__(self,theList,lock):
        self.theList = theList
        self.lock = lock
        self.start()


    def run(self):
        while True:
            # do some stuff that eventually needs to work with theList
            self.lock.acquire()
            try:
                self.theList.remove(something)
            finally:
                self.lock.release()



if __name__ == "__main__":
    lock = threading.Lock()
    aList = []
    for x in range(10):
        B(aList,lock)

    A(aList,lock).poll()

Answer 1

在一般情况下，只要是RLock（可重入）而不是普通Lock，单个全局锁效率较低（争用更多）但更安全（没有死锁风险）。

当持有锁执行的线程试图获取另一个（或相同的）锁时，例如通过调用包含acquire调用的另一个方法，可能会出现问题。如果一个已经持有锁的线程试图再次获取它，如果锁是一个普通的Lock，它将永远阻塞，但如果它稍微复杂RLock则会顺利进行 - 这就是为什么后者是称为 reentrant ，因为持有它的线程可以再次“输入”（获取锁定）。从本质上讲，RLock会跟踪哪个线程持有它，以及线程获取锁定的时间，而更简单的Lock不会保留此类信息。

使用多个锁时，当一个线程尝试获取锁A然后锁定B时会出现死锁问题，而另一个线程尝试获取第一个锁B，然后锁定A.如果发生这种情况，那么迟早你将会遇到第一个锁持有A的情况，第二个持有B，每个都试图获取另一个持有的锁 - 所以两者都永远阻止。

防止多锁死锁的一种方法是确保始终以相同的顺序获取锁，无论线程正在进行获取。但是，当每个实例都有自己的锁时，这非常难以以任何清晰和简单的方式进行组织。

Answer 2

如果在每个类中使用单独的锁定对象，则存在死锁风险，例如：如果一个操作声明锁定A，然后声明锁定B，而另一个操作声明B然后A。

如果您使用单个锁，那么当可以并行运行不同的操作时，您将强制代码转换为单个线程。这在Python中并不总是那么严重（在任何情况下都有全局锁定），就像在其他语言中一样，但是说你在写入文件时要保持全局锁定Python会释放GIL但是你已经阻止了一切其他

所以这是一个权衡。我会说你可以选择小锁，这样你就可以最大限度地提高并行执行的几率，但是要注意不要一次声称有多个锁，并且尽量不要长时间保持锁定。

就你的具体例子而言，第一个就是简单的。如果您锁定theList上的操作，则每次都必须使用相同的锁，否则您不会锁定任何内容。这可能无关紧要，因为list.append和list.remove无论如何都是有效的原子，但是如果你确实需要锁定对列表的访问，你需要确保每次都使用相同的锁。执行此操作的最佳方法是将列表和锁定作为类的属性，并强制对列表的所有访问权限通过包含类的方法。然后传递容器类而不是列表或锁。

Python锁定实现（带有线程模块）

样本1

样本2

2 个答案: