python线程死锁

死锁产生的4个必要条件：
    1、互斥：一个资源同一时刻只允许一个线程进行访问。
    2、占有未释放：一个线程占有资源，且没有释放资源。
    3、不可抢占：一个已经占有资源的线程无法抢占到其他线程拥有的资源。
    4、循环等待：两个或者两个以上的线程，本身拥有资源，不释放资源，并且同时尝试获得其他线程所持有的资源，这种资源的申请关系形成一个闭环的链条。

死锁的避免：

关于死锁的避免，仁者见仁智者见智。

主要还是从造成死锁的四个条件入手，四个条件不能满足，就不会死锁。

以下是我本人的一些方法：

1.线程等待时（wait）给予一个默认的等待时间

2.线程之间资源避免相互申请对方的资源，可以通过一些容器来控制并发，比如blockqueue，等等一些线程安全的容器

3.尽量避免线程在等待的同时申请资源

4.死锁检测，一个线程在等待一段时间后还没有获得资源就放弃申请。对等待时间进行检测。

一个死锁的例子：

# 线程死锁，在classA和classB相互调用对方的方法，并且相互等待对方释放资源


class ClassA:
    def __init__(self):
        self.lock=threading.RLock()

    # 得到classA的锁，试图得到classB的锁
    def infoA(self, b):
        self.lock.acquire()
        time.sleep(10)
        b.info()
        self.lock.release()

    def info(self):
        self.lock.acquire()
        print("this is ClassA info")
        self.lock.release()


class ClassB:
    def __init__(self):
        self.lock = threading.RLock()

    # 得到classB的锁，试图得到classA的锁
    def infoB(self, a):
        self.lock.acquire()
        time.sleep(10)
        a.info()
        self.lock.release()

    def info(self):
        self.lock.acquire()
        print("this is ClassB info")
        self.lock.release()


ca=ClassA()
cb=ClassB()

def funA():
    ca.infoA(cb)
def funB():
    cb.infoB(ca)

# 函数调用不是线程，不会死锁
# funA()
# funB()

t1=threading.Thread(target=funA).start()
t2=threading.Thread(target=funB).start()

说明：

线程|状态
classA	获得classA的锁，sleep（classA的锁未释放）	申请classB的锁	死锁
classB	获得classB的锁，sleep（classB的锁未释放）	申请classA的锁	死锁