多线程死锁问题

多线程死锁问题

在多线程同步使用的时候存在数据的不安全问题，python解释器在底层添加了GIL全局解释器锁机制来控制锁的安全问题，但不是绝对的安全。在日常的开发中还需要开发者添加锁机制在代码中。

二、锁机制

多线程锁用到的是Lock和RLock模块

• 获取钥匙：acquire()
• 归还钥匙：release()

三、死锁问题

• 原因：
  在开发过程中使用多线程，线程之间共享资源，如果两个线程分别占有一部分资源并且等待对方归还资源，那么就会造成死锁。死锁情况很少见，但是一旦出现就会造成程序停止运行，不做任何事情。

from threading import Thread, Lock
import time

class Mythread(Thread):
    def __init__(self):
        super().__init__()

    def run(self):
        if lockA.acquire():
            # 如果可以获取到锁，返回的是True，这是一个bool类型的
            print(self.name + '获取了A锁')
            # time.sleep(0.1)
            if lockB.acquire():
                print(self.name + '又获取了B锁，原来还有A锁')
                lockB.release()
            lockA.release()

class Mythread1(Thread):
    def __init__(self):
        super().__init__()

    def run(self):
        if lockB.acquire():
            # 如果可以获取到锁，返回的是True，这是一个bool类型的
            print(self.name + '获取了B锁')
            # time.sleep(0.1)
            if lockA.acquire():
                print(self.name + '又获取了A锁，原来还有B锁')
                lockA.release()
            lockB.release()

if __name__ == '__main__':
    lockA = Lock()
    lockB = Lock()
    m = Mythread()
    m.start()
    m1 = Mythread1()
    m1.start()

• 解决办法：
  • 重构代码，修改逻辑，但是这种方比较耗时，效率不高
  • 在第一个线程中试图获取另外一个锁的acquire中添加timeout=秒数，来设定线程试图获取另外一个锁多久，超出时间自动终止，这样就另外一个线程就可以获取到锁，不会出现死锁的情况。

from threading import Thread, Lock
import time

class Mythread(Thread):
    def __init__(self):
        super().__init__()

    def run(self):
        if lockA.acquire():
            # 如果可以获取到锁，返回的是True，这是一个bool类型的
            print(self.name + '获取了A锁')
            # time.sleep(0.1)
            if lockB.acquire(timeout=5):
                # 设定等待时间，超出时间释放锁，解决死锁的问题
                print(self.name + '又获取了B锁，原来还有A锁')
                lockB.release()
            lockA.release()

class Mythread1(Thread):
    def __init__(self):
        super().__init__()

    def run(self):
        if lockB.acquire():
            # 如果可以获取到锁，返回的是True，这是一个bool类型的
            print(self.name + '获取了B锁')
            # time.sleep(0.1)
            if lockA.acquire():
                print(self.name + '又获取了A锁，原来还有B锁')
                lockA.release()
            lockB.release()

if __name__ == '__main__':
    lockA = Lock()
    lockB = Lock()
    m = Mythread()
    m.start()
    m1 = Mythread1()
    m1.start()

线程之间出现死锁的问题本质在于资源分配顺序上的问题。

多线程死锁问题

原文：https://www.cnblogs.com/ddzc/p/12462888.html