9.递归锁

首先了解一下死锁：

两个线程互相需要对方的锁才能进行下一步时陷入的等待状态

如：a线程需要b线程的c锁，b线程需要a线程的d锁

举例：

class Mythread(threading.Thread):
    def A(self):
        LockA.acquire()
        print(self.name,'DoA',time.ctime())
        time.sleep(2)
        LockB.acquire()
        print(self.name,'Dob',time.ctime())
        LockB.release()
        LockA.release()

    def B(self):
        LockB.acquire()
        print(self.name,'DoB',time.ctime())
        time.sleep(2)
        LockA.acquire()
        print(self.name,'DoA',time.ctime())
        LockA.release()
        LockB.release()
    def run(self):
        self.A()
        self.B()
if __name__ == "__main__":
    LockA=threading.Lock()
    LockB=threading.Lock()
    threads=[]
    for i in range(5):
        threads.append(Mythread())
    for i in threads:
        i.start()
    for i in threads:
        i.join()

进程1中的B函数占用loCKB想要locka,进程而中的a函数占用locka想要lockb,程序会卡在原地

这种方式要在代码编写的过程中避免，可以使用Rlock递归锁来实现该功能

递归锁：

Rlock  递归锁，可重用 ，可以被多次成对的获取和释放

只有一把锁，5个进程抢占一把解释器，然后在进程加入递归锁，可以被重复的获取释放

解决上一段代码中的死锁问题：

class Mythread(threading.Thread):
    def A(self):
        Lock.acquire()
        print(self.name,'DoA',time.ctime())
        time.sleep(2)
        Lock.acquire()
        print(self.name,'Dob',time.ctime())
        Lock.release()
        Lock.release()

    def B(self):
        Lock.acquire()
        print(self.name,'DoB',time.ctime())
        time.sleep(2)
        Lock.acquire()
        print(self.name,'DoA',time.ctime())
        Lock.release()
        Lock.release()
    def run(self):
        self.A()
        self.B()
if __name__ == "__main__":
    Lock=threading.RLock()
    threads=[]
    for i in range(5):
        threads.append(Mythread())
    for i in threads:
        i.start()
    for i in threads:
        i.join()