避免死锁方法之银行家算法

要介绍银行家算法应该先简单说一下死锁：

死锁

死锁概念：在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源时，就会造成死锁。尽管死锁很少发生，但一旦发生就会造成应用的停止响应。

死锁的两种情况：

1. 同一个线程先后两次调用lock,在第二次调用时,由于锁已经被自己占用,该线程会挂起等待自己释放锁,由于该线程已被挂起而没有机会释放锁,因此 它将一直处于挂起等待状态，变为死锁；

2. 线程A获得了锁1,线程B获得了锁2,这时线程A调用lock试图获得锁2,结果是需要挂起等待线程B释放锁2,而这时线程B也调用lock试图获得锁1,结果是需要挂起等待线程A释放锁1,于是线程A和B都在等待对方释放自己才释放，从而造成两个都永远处于挂起状态，造成死锁。

产生死锁的必要条件：

1. 互斥条件：指线程对所分配到的资源进行排它性使用，即在一段时间内某资源只由一个线程占用。如果此时还有其它线程程请求资源，则请求者只能等待，直至占有资源的进程用毕释放。

2. 请求和保持条件：指线程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其它进程占有，此时请求线程阻塞，但又对自己已获得的其它资源保持不放。

3. 不剥夺条件：指线程已获得的资源，在未使用完之前，不能被剥夺，只能在使用完时由自己释放。

4. 环路等待条件：指在发生死锁时，必然存在一个线程——资源的环形链，即线程集合{P0，P1，P2，···，Pn}中的P0正在等待一个P1占用的资源；P1正在等待P2占用的资源，……，Pn正在等待已被P0占用的资源。

如何避免死锁呢？

理解了死锁的原因，尤其是产生死锁的四个必要条件，就可以最大可能地避免、预防和解除死锁。所以，在系统设计、线程调度等方面注意如何能够不让这四个必要条件成立，如何确定资源的合理分配算法，避免线程永久占据系统资源。

此外，也要防止线程在处于等待状态的情况下占用资源,在系统运行过程中，对线程发出的每一个系统能够满足的资源申请进行动态检查，并根据检查结果决定是否分配资源，若分配后系统可能发生死锁，则不予分配，否则予以分配。因此，对资源的分配要给予合理的规划，银行家算法就是一种很好解决的方式

银行家算法原理

这里是引用一个银行家共有20亿财产
第一个开发商：已贷款15亿，资金紧张还需3亿。
第二个开发商：已贷款5亿，运转良好能收回。
第三个开发商：欲贷款18亿

在这种情况下，如果你是银行家，你怎么处理这种情况？一个常规的想法就是先等着第二个开发商把钱收回来，然后手里有了5个亿，再把3个亿贷款给第一个开发商，等第一个开发商收回来18个亿，然后再把钱贷款给第三个开发商。

银行家算法是避免死锁的一种重要方法。 操作系统按照银行家制定的规则为线程分配资源，当线程首次申请资源时，要测试该线程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。当线程在执行中继续申请资源时，先测试该线程已占用的资源数与本次申请的资源数之和是否超过了该线程对资源的最大需求量。若超过则拒绝分配资源，若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配。

银行家算法具体介绍

每一个线程进入系统时，它必须声明在运行过程中，所需的每种资源类型最大数目，其数目不应超过系统所拥有每种资源总量，当线程请求一组资源系统必须确定有足够资源分配给该进程，若有在进一步计算这些资源分配给进程后，是否会使系统处于不安全状态，不会（即若能在分配资源时找到一个安全序列），则将资源分配给它，否则等待。

假定系统中有五个线程{P0，P1，P2，P3，P4}和三类资源{A,B,C},各类资源数量分别为10,5,7,在T0时刻分配资源情况如图：

• Max:表示线程对每类资源的最大需求量；
• Allocation:表示系统给线程已分配每类资源的数目；
• Need:表示线程还需各类资源数目；
• Available:表示系统当前剩下的资源。
  

从初始找出安全序列：

1. 首先系统剩下资源{3,3,2}，查表可满足5个进程Need的进程有：P1(1,2,2)、P3(0,1,1),先给P1分配；
2. P1分配以后执行完释放其所占资源后系统此时剩下资源有：Allocation+{3,3,2}={5,3,2};
3. 根据系统剩下资源查表可满足剩下4个进程Need的进程有P3{0,1,1}、P4{4,3,1}，再给P3分配；
4. P3分配以后执行完释放其所占资源后系统此时剩下资源有：Allocation+{5,3,2}={7,4,3};
5. 根据系统剩下资源查表可满足剩下3个进程Need的进程有P0{7,4,3}、P2{6,0,0}、P4{4,3,1},再给P4分配；
6. P4分配以后执行完释放其所占资源后系统此时剩下资源有：Allocation+{7,4,3}={7,4,5};
7. 根据系统剩下资源查表可满足剩下2个进程Need的进程有P0{7,4,3}、P2{6,0,0},再给P2分配;
8. P2分配以后执行完释放其所占资源后系统此时剩下资源有：Allocation+{7,4,5}={10,4,7};
9. 根据系统剩下资源查表可满足剩下1个进程Need的进程有P0{7,4,3},最后给P0分配;
10. P0分配以后执行完释放其所占资源后系统此时剩下资源有：Allocation+{10,4,7}={10,5,7};
11. 所有进程按此序列{P1,P3,P4,P2,P0}可安全执行完毕，最后系统资源全部释放。（由以上也可知安全序列不唯一，但只要找出一个安全序列，说明此系统是安全的（找到安全序列可按此序列真正执行进程推进顺序，若没找到，则恢复初始状态，其并没有真正给进程分配资源，只是提前避免））

下面用代码实现银行家算法

#function：命令行界面实现对各进程请求通过银行家算法实现分配资源
import numpy as np                                                                      #导入numpy模块

#初始化各数据结构
Available = np.array([3,3,2])                                             #可利用各资源总数
Max = np.array([[7,5,3],[3,2,2],[9,0,2],[2,2,2],[4,3,3]])                 #各进程最大需求资源数
Allocation = np.array([[0,1,0],[2,0,0],[3,0,2],[2,1,1],[0,0,2]])          #已分配各进程的资源数
Need = np.array([[7,4,3],[1,2,2],[6,0,0],[0,1,1],[4,3,1]])                #各进程尚需的资源数
safeList=[]                                                               #安全进程执行序列
Request=[]                                                                #各进程对各资源的请求
Request_name=""                                                           #进程名称


def input_Request():
    global Allocation,Available,Max,Need,safeList,Request,Request_name
    try:
        Request_name=input("请输入请求线程的编号：\n0   1    2    3    4\n")
        Request_name=int(Request_name)
        Request_new=input("请输入P{}的请求资源数(如：* * *) :\n".format(Request_name))
        Request_new=list(Request_new)

        for x in range(0,5,2):                                                          #去除输入的空格
            i=int(Request_new[x])
            Request.append(i)

        Request=np.array(Request)
    except:
        print("输入错误，请重新输入")
        input_Request()



def BankerAlgorithm():
    global Allocation,Available,Max,Need,safeList,Request,Request_name
    input_Request()

    if ((Request<=Need[Request_name]).all()):
        if ((Request<=Available).all()):
            Available -=Request                                                          #可利用资源减少

            Need[Request_name] -= Request                                                #尚需的资源数减少
            Allocation[Request_name] +=Request                                           #已分配资源增加
            safeAlgorithm()                                                              #执行安全算法
        else:
            print("请求超出可利用的资源，请等待")
    else:
        print("线程请求超出所需总资源数")

def safeAlgorithm():
    work = Available                                                                      #分配work向量
    Finish=[False]*5                                                                    #分配Finish向量


    while False in Finish:
        for i in range(0,5):
           for j in range(0,3):
                if ((Finish[i]==False) and ((Need[i]<=work).all())):
                    for m in range(3):
                        work[m] =work[m]+ Allocation[i][m]
                    Finish[i]=True
                    safeList.append(i)
                else:
                    break

    if False in Finish:
        print("*"*45)
        print("您输入的请求资源数:{}".format(Request))
        print("您输入的请求进程是{}".format(Request_name))
        print("系统安全性：不安全状态")
        print("*"*45)
    else:
        print("*"*45)
        print("您输入的请求进程是{}".format(Request_name))
        print("您输入的请求资源数:{}".format(Request))
        print("系统安全性：系统安全")
        print("安全序列为：",safeList)
        print("*"*45)

if __name__ =="__main__":

    BankerAlgorithm()