Python锁定实现(带有线程模块)

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- 这就是后者被称为可重入的原因,因为持有它的线程可以"再次输入"(获取锁定).本质上,RLock会跟踪哪个线程持有它,以及线程获取锁定的时间,而更简单的Lock不会保留此类信息.

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

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

Answer 2

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

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

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

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