银行家算法解题思路

首先你一定要知道这个算法是伟大的地杰斯特拉设计的。

这个算法是干啥的我就不介绍了，不知道的需要百度一下。

接下来的几个名词很重要一定要记住：

可利用资源向量Available——就是系统可以分配的每种资源有多少

最大需求矩阵MAX——就是进程能获得的每种资源的数量是多少

分配矩阵Allocation——就是进程现在分到了多少资源

Need——每个进程还需要的剩余资源

Need[i][j]=max[i][j]-allocation[i][j]

Request[ i ]表示进程Pi进程的申请向量，如 Request[ i ][ j ]=m表示Pi申请m个Rj类资源

向量Free[ j ]表示系统可分配给各进程的Rj类资源数目，初始与当前Available等值

向量Finish[ i ]表示进程Pi在此次检查中是否被满足，初始均为false

当有足够的资源分配给进程时，finish[i]=true,pi完成释放资源(Free[j]+=Allocation[i][j])

接下来我用代码的方式展示一下这个算法的实现过程：

if( Request[ i ][ j ]<=Need[ i ][ j ] &&  Request[ i ][ j ]<=Available[ j ] )

/*这步是检测资源申请量是否满足说明最大值和可调用的最大值，前者判断不合格会导致程序出错（因为它不符合说明），后者出错会导致程序wait，对后续进程需求进行检测，若出现不符合的则安全检查结束，当前进程进入等待*/

{

Available[ j ]  =Available[ j ] — Request[ i ][ j ];

Allocation[ i ][ j ]=Allocation[ i ][ j ] +Request[ i ][ j ];

Need[ i ][ j ]=Need[ i ][ j ]— Request[ i ][ j ];

/*可分配的量、进程已经分配到的资源、进程还剩多少资源更新*/

int trueSum=0, i=0 ; boolean Flag=true;

while( trueSum<P.length-1 && Flag==true ){

/*这里结束的条件是判断完所有的进程均安全或者出现任一不安全的进程*/

i=i%P.length;

Available[ j ]  =Available[ j ] — Request[ i ][ j ];

Allocation[ i ][ j ]=Allocation[ i ][ j ] +Request[ i ][ j ];

Need[ i ][ j ]=Need[ i ][ j ]— Request[ i ][ j ];

//对释放的资源进行重现更新,第一轮不需要更新，这里不写了

if( Finish[ i ]==false ){

if(Need[ i ][ j ]<Free[ j ]){

Free[ j ]+=Allocation[ i ][ j ];

Finish[ i ]=true;

trueSum++;

i++;

}else{

Flag=false;

}

}

/*判断进程是否安全，并且更新free的空间（free即下次可分配的空间）*/

if( Flag==false)

pass;

Else

Nopass;

}

}

/*这段代码主要是理解思路，有疑问请酌情理解*/

 

举个例子来看这个垃圾代码：

考虑这样一个系统，有5个进程P0~P4，3种资源类型A、B、C。资源类型A有10个实例，资源类型B有5个实例，资源类型C有7个实例。假定在时刻T0，系统状态如下：问它是不是处于安全状态。

        Allocation       Max      Avaliable

       A  B  C      A  B  C    A  B  C

P0       0  1  0      7  5  3    3  3  2

P1       2  0  0      3  2  2  

P2       3  0  2      9  0  2

P3       2  1  1      2  2  2

P4       0  0  2      4  3  3

 

 

有的题不会给出need，所以我们需要自己算出need，need的初始化值是max-allocation；

 

 

            Need

        A  B  C

P0       7  4  3

P1       1  2  2

P2       6  0  0

P3       0  1  1

P4       4  3  1

 

然后根据上面的银行家算法我们可以对他们进行判断是否安全：

           Need         Free           Allocation      

       A  B  C        A  B  C         A    B   C

P1      1  2  2     3  3  2        2   0   0

P3      0  1  1     5  3  2        2   1   1

P4      4  3  1     7  4  3       0   0   2

P0      7  4  3     7  4  5       0   1   0

P2      4  3 1     7  5  5       3   0   2

 

（接上表）

     Free+Allocation      Finish         

       A  B  C         

P1      5  3  2     true   

P3      7  4  3     true  

P4      7  4  5     true

P0      7  5  5     true

P2      10 5 7     true

 

 

因此我们按照P1 P3 P4 P0 P2 的顺序进行银行家算法，可知T0状态下程序是安全的。

 

 

银行家算法的安全序列并不唯一，快速找出安全序列也是解题的关键：

一般情况下是找need需最少的和allocation最大的，依次寻找，当然可能存在特殊情况，因题而异。

 

 

然后这类问题会问在某时刻的request的值，一定要满足上述的<=need(否则直接over)，且满足<=available（循环中是free，不满足则等待）。

如果问在某request的基础上进行什么操作，如果那个request没有使进程finish的话不能在其free上加allocation。

 

针对以上两点，我们依然利用以上例题（我把表防到下面，好查看），问一下三个问题：

1、 在T0时刻，若进程P0发出资源请求request（2,0,2），能否实施资源分配？

2、 在问题1的基础上，P3发出资源请求request（0,1,1），能否实施资源分配？

3、 在问题1的基础上，P4发出资源请求request（1,3,0），能否实施资源分配？

 

 

 

  Allocation       Max      Avaliable

       A  B  C      A  B  C    A  B  C

P0       0  1  0      7  5  3    3  3  2

P1       2  0  0      3  2  2  

P2       3  0  2      9  0  2

P3       2  1  1      2  2  2

P4       0  0  2      4  3  3

 

 Need

        A  B  C

P0       7  4  3

P1       1  2  2

P2       6  0  0

P3       0  1  1

P4       4  3  1

 

 

 

解：

1、 能。因为P0的request(2,0,2)<need(7,4,3)并且<available(3,3,2);

2、 不能。因为要在问题1的基础上，此时问题一分配的资源并没有达到它的need值，因此此时avaliable的值为(1,3,0),P3的request(0,1,1)<=need(0,1,1)但是>available(1,3,0)。因此不能

3、 能。分析参照题2。