[目的要求]

银行家算法是由Dijkstra设计的最具有代表性的避免死锁的算法。本实验要求用高级语言编写一个银行家的模拟算法。

通过本实验可以对预防死锁和银行家算法有更深刻的认识。

[试验内容]

1、 设置数据结构

包括可利用资源向量（Availiable）,最大需求矩阵（Max）,分配矩阵（Allocation）,需求矩阵（Need）

2、 设计安全性算法

设置工作向量Work表示系统可提供进程继续运行可利用资源数目，Finish表示系统是否有足够的资源分配给进程

[银行家算法] 

一.构建银行家算法中的数据结构

根据课本P101图3-16中的进程和资源情况，构建Available，Max，Allocation，Need矩阵。

二.银行家算法

   0.执行安全性算法，检查系统是否处于安全状态。

1.输入进程i的请求向量request

2.如果request[i]<=Need[i],执行步骤三，否则结束，并报错

3.系统尝试把资源分配给进程Pi，修改以下资源的值：

  available[j]=available[j]-request[j]

        Allocation[i][j]=Allocation[i][j]+request[j]

       need[i][j]=need[i][j]-request[j]

4.执行安全性算法，若安全，完成分配，若不安全，还原资源：

  available[j]=available[j]+request[j]

  Allocation[i][j]=Allocation[i][j]-request[j]

      need[i][j]=need[i][j]+request[j]

三．安全性算法

1.设置工作向量work，使其等于Available，设置finish向量，使其所有值都为false

2.从进程集合中找到满足下列条件的进程：

  Finish[i]值为false

Need[i,j]<=work[j]

若找到，执行步骤3，否则执行步骤4

   3.进程获取资源顺利执行，释放资源：

     Work[j]=work[j]+allocation[j]

Finish[i]=true

执行步骤2

   4.如果所有的进程的finish都为true，则安全，否则不安全。

四.编码

available=[3,3,2]
Max=[[7,5,3],[3,2,2],[9,0,2],[2,2,2],[4,3,3]]
Allocation=[[0,1,0],[2,0,0],[3,0,2],[2,1,1],[0,0,2]]
need=[]
f=[]
for i in range(5):
    for j in range(3):
        f+=[Max[i][j]-Allocation[i][j]]
    need.append(f)
    f=[]
def bank():
    if safe()==1:
        print('此时系统安全，正在尝试分配')
    i=input('请输入进程序号')
    i=int(i)
    print('请输入请求向量')
    request=[]
    for j in range(3):
        a=input()
        request.append(int(a))
    print(request)
    for j in range(3):
        if request[j]>need[i][j]:
            print('分配出错')
            return 0
    for j in range(3):
        if request[j]>available[j]:
            print("资源不够，还需等待")
            return 0
    for j in range(3):
        available[j]=available[j]-request[j]
        Allocation[i][j]=Allocation[i][j]+request[j]
        need[i][j]=need[i][j]-request[j]
    if safe()==1:
        print('完成此次分配')
    else:
        print('分配不安全，禁止分配')
        for j in range(3):
            available[j]=available[j]+request[j]
            Allocation[i][j]=Allocation[i][j]-request[j]
            need[i][j]=need[i][j]+request[j]
def safe():
    work=[]
    work=work+available
    finish=[0,0,0,0,0]
    while(True):
        for i in range(5):
            c=0
            if finish[i]==0:
                for j in range(3):
                    if need[i][j]<=work[j]:
                        c=c+1
                if c==3:
                   ii=i
                   break;
        if c==3:
            for j in range(3):
                work[j]=work[j]+Allocation[ii][j]
            finish[ii]=1
        else:
           if sum(finish)==5:
              return 1
           else:
               return 0

while(1):
    z=input('是否结束分配，是请按1，否请按0:')
    if z=='1':
        break
    bank()