在python中解决死锁的问题

1.添加超时时间：

fromthreading import Thread, Lock
importtime 
mutex1= Lock()  # 创建一个互斥锁
mutex2= Lock()  # 创建一个互斥锁

def fun1():
    while True:
        mutex1.acquire()
        print("线程1 锁住了mutex1")
        time.sleep(0.1)
 
        result =mutex2.acquire(timeout=1)  # timeout指明acquire等的最长超时时间
        # result = mutex2.acquire(False)  # 非阻塞
        if result:
            # 表示对mutex2成功上锁
            print("线程1 锁住了mutex2")
            print("线程1 hello")
            mutex1.release()
            mutex2.release()
            break
        else:
            # 表示对mutex2上锁失败
           mutex1.release()  # 将mutex1释放，保证别人能够执行
            time.sleep(0.1)

def fun2():
    mutex2.acquire()
    print("线程2 锁住了mutex2")
    time.sleep(0.1)
    mutex1.acquire()
    print("线程2 锁住了mutex1")
    print("线程2 hi") 
    mutex1.release()
    mutex2.release()

2.附录-银行家算法（ 不要求，理解就可以）

背景知识

一个银行家如何将一定数目的资金安全地借给若干个客户，使这些客户既能借到钱完成要干的事，同时银行家又能收回全部资金而不至于破产，这就是银行家问题。这个问题同操作系统中资源分配问题十分相似：银行家就像一个操作系统，客户就像运行的进程，银行家的资金就是系统的资源。

问题的描述

一个银行家拥有一定数量的资金，有若干个客户要贷款。每个客户须在一开始就声明他所需贷款的总额。若该客户贷款总额不超过银行家的资金总数，银行家可以接收客户的要求。客户贷款是以每次一个资金单位（如1万RMB等）的方式进行的，客户在借满所需的全部单位款额之前可能会等待，但银行家须保证这种等待是有限的，可完成的。

例如：有三个客户C1，C2，C3，向银行家借款，该银行家的资金总额为10个资金单位，其中C1客户要借9各资金单位，C2客户要借3个资金单位，C3客户要借8个资金单位，总计20个资金单位。某一时刻的状态如图所示。

对于a图的状态，按照安全序列的要求，我们选的第一个客户应满足该客户所需的贷款小于等于银行家当前所剩余的钱款，可以看出只有C2客户能被满足：C2客户需1个资金单位，小银行家手中的2个资金单位，于是银行家把1个资金单位借给C2客户，使之完成工作并归还所借的3个资金单位的钱，进入b图。同理，银行家把4个资金单位借给C3客户，使其完成工作，在c图中，只剩一个客户C1，它需7个资金单位，这时银行家有8个资金单位，所以C1也能顺利借到钱并完成工作。最后（见图d）银行家收回全部10个资金单位，保证不赔本。那麽客户序列{C1，C2，C3}就是个安全序列，按照这个序列贷款，银行家才是安全的。否则的话，若在图b状态时，银行家把手中的4个资金单位借给了C1，则出现不安全状态：这时C1，C3均不能完成工作，而银行家手中又没有钱了，系统陷入僵持局面，银行家也不能收回投资。

综上所述，银行家算法是从当前状态出发，逐个按安全序列检查各客户谁能完成其工作，然后假定其完成工作且归还全部贷款，再进而检查下一个能完成工作的客户，......。如果所有客户都能完成工作，则找到一个安全序列，银行家才是安全的。

补充：python基础-死锁、递归锁

死锁

所谓死锁：是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程

from threading import Thread,Lock
import time
mutexA=Lock()
mutexB=Lock()
class MyThread(Thread):
    def run(self):
        self.func1()
        self.func2()
    def func1(self):
        mutexA.acquire()
        print('\033[41m%s 拿到A锁\033[0m' %self.name)
        mutexB.acquire()
        print('\033[42m%s 拿到B锁\033[0m' %self.name)
        mutexB.release()
        mutexA.release()
    def func2(self):
        mutexB.acquire()
        print('\033[43m%s 拿到B锁\033[0m' %self.name)
        time.sleep(2)
        mutexA.acquire()
        print('\033[44m%s 拿到A锁\033[0m' %self.name)
        mutexA.release()
        mutexB.release()
if __name__ == '__main__':
    for i in range(5):
        t=MyThread()
        t.start()

输出如下：

Thread-1 拿到A锁

Thread-1 拿到B锁

Thread-1 拿到B锁

Thread-2 拿到A锁

分析如上代码是如何产生死锁的：

启动5个线程，执行run方法，假如thread1首先抢到了A锁，此时thread1没有释放A锁，紧接着执行代码mutexB.acquire()，抢到了B锁，在抢B锁时候，没有其他线程与thread1争抢，因为A锁没有释放，其他线程只能等待，然后A锁就执行完func1代码，然后继续执行func2代码，与之同时，在func2中，执行代码 mutexB.acquire()，抢到了B锁，然后进入睡眠状态，在thread1执行完func1函数，释放AB锁时候，其他剩余的线程也开始抢A锁，执行func1代码，如果thread2抢到了A锁，接下来thread2要抢B锁，ok，在这个时间段，thread1已经执行func2抢到了B锁，然后在sleep(2),持有B锁没有释放，为什么没有释放，因为没有其他的线程与之争抢，他只能睡着，然后thread1握着B锁，thread2要抢B锁，ok，这样就形成了死锁

递归锁

我们分析了死锁，那么python里面是如何解决这样的递归锁呢？

在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。

这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁：

from threading import Thread,Lock,RLock
import time
mutexA=mutexB=RLock()
class MyThread(Thread):
    def run(self):
        self.f1()
        self.f2()
    def f1(self):
        mutexA.acquire()
        print('%s 拿到A锁' %self.name)
        mutexB.acquire()
        print('%s 拿到B锁' %self.name)
        mutexB.release()
        mutexA.release()
    def f2(self):
        mutexB.acquire()
        print('%s 拿到B锁' % self.name)
        time.sleep(0.1)
        mutexA.acquire()
        print('%s 拿到A锁' % self.name)
        mutexA.release()
        mutexB.release()
if __name__ == '__main__':
    for i in range(5):
        t=MyThread()
        t.start()

输出代码如下：

E:\python\python_sdk\python.exe "E:/python/py_pro/3 死锁现象与递归锁.py"

Thread-1 拿到A锁

Thread-1 拿到B锁

Thread-1 拿到B锁

Thread-1 拿到A锁

Thread-2 拿到A锁

Thread-2 拿到B锁

Thread-2 拿到B锁

Thread-2 拿到A锁

Thread-4 拿到A锁

Thread-4 拿到B锁

Thread-4 拿到B锁

Thread-4 拿到A锁

Thread-3 拿到A锁

Thread-3 拿到B锁

Thread-3 拿到B锁

Thread-3 拿到A锁

Thread-5 拿到A锁

Thread-5 拿到B锁

Thread-5 拿到B锁

Thread-5 拿到A锁

Process finished with exit code 0

或者如下的效果：

来解释下递归锁的代码：

由于锁A，B是同一个递归锁，thread1拿到A,B锁，counter记录了acquire的次数2次，然后在func1执行完毕，就释放递归锁，在thread1释放完递归锁，执行完func1代码，接下来会有2种可能，1、thread1在次抢到递归锁，执行func2代码 2、其他的线程抢到递归锁，去执行func1的任务代码

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。如有错误或未考虑完全的地方，望不吝赐教。