银行家算法

一、算法思想：在进程请求资源之前

1、实际资源检测：

　　Request < Need

　　Request < Available

2、假分配检测：

　　假设进行分配，预测是否会产生死锁。

3、程序结构：

if(Request > Need[i])    error;
if(Request > Available)    sleep();
//假设分配
Available -= Request;
Allocation[i] += Request;
Need[i] -=Request;
//检测分配后是否死锁
if(!isSafe()) {
    //不分配，还原假设分配操作
}else
    //分配

二、实例：参考这里

　　假设系统中有A、B、C三种资源，P1~P5共5个进程，某时刻三种资源数量Available =（3，3，2）。其他状态如下：

	MAX（最多需要资源）	Allocation（已分配资源）	Need（还需资源）
P1	7　　5　　3	0　　1　　0	7　　4　　3
P2	3　　2　　2	2　　0　　0	1　　2　　2
P3	9　　0　　2	3　　0　　2	6　　0　　0
P4	2　　2　　2	2　　1　　1	0　　1　　1
P5	4　　3　　3	0　　0　　2	4　　3　　1

　　某时刻P2发出请求向量Request =（1,0,2），根据银行家算法：

　　　　Request < Need (P2) 且 Request < Available;

　　假设预分配给P2，则得到如下状态：Available = （2，3，0）

	MAX（最多需要资源）	Allocation（已分配资源）	Need（还需资源）
P1	7　　5　　3	0　　1　　0	7　　4　　3
P2	3　　2　　2	3　　0　　2	0　　2　　0
P3	9　　0　　2	3　　0　　2	6　　0　　0
P4	2　　2　　2	2　　1　　1	0　　1　　1
P5	4　　3　　3	0　　0　　2	4　　3　　1

 　　此时根据isSafy()判断，先将Available分配给P2，P2执行结束后Available = （5，3，2）；在分配给P4，执行结束后Available = （7，4，3）；分配给P5，结束后Available = （7，4，5）；分配给P1，结束后Available = （7，5，5）；分配给P3，执行后Available = （10，5，7）。最后所有进程全部执行结束，不会死锁，isSafy为真，可以分配。

三、银行家算法C++实现：

#include<iostream>
using namespace std;
int numR,numP,*Max,*Allocation,*Need,*Available,*Request;


void banker(int p);
int main(){
    Max = (int *)malloc(sizeof(int)*numR*numP);
    Allocation = (int *)malloc(sizeof(int)*numR*numP);
    Need = (int *)malloc(sizeof(int)*numR*numP);
    Available = (int *)malloc(sizeof(int)*numR);
    Request = (int *)malloc(sizeof(int)*numR);
    cin>>numR>>numP;
    for(int i=0; i<numP; i++){
        for(int j=0; j<numR; j++){
            cin>>Max[i*numR + j];
        }
    }
    for(i=0; i<numP; i++){
        for(int j=0; j<numR; j++){
            cin>>Allocation[i*numR + j];
            Need[i*numR + j] = Max[i*numR + j] - Allocation[i*numR + j];
        }
    }
    for(i=0; i<numR; i++)
        cin>>Available[i];
    while(1){
        int p;
        cin>>p;
        for(int i=0; i<numR; i++){
            cin>>Request[i];
        }
        banker(p);
    }
}
bool compare(int *a,int *b){
    for(int i=0; i<numR; i++){
        if(a[i] < b[i]){
            return false;
        }
    }
    return true;
}
bool isSafy(){
    int *flags = (int *)malloc(sizeof(int)*numP);
    memset(flags,0,sizeof(int)*numP);
    int num=0;
    while(num<=numP){
        if(!flags[num]&&compare(Available, &Need[num*numR])){
            for(int i=0;i<numR;i++){
                Available[i] +=Allocation[num*numR+i];
            }
            flags[num] = 1;
            num=0;
        }else{
            num++;
        }
    }
    for(int i=0; i<numP; i++){
        if(!flags[i])
            return false;
    }
    return true;    
}
void banker(int p){
    if(compare(Request,&Need[p*numR])){
        cout<<"Error!"<<endl;
        return;
    }
    if(compare(Request,Available)){
        cout<<"Block!"<<endl;
        return;
    }
    for(int i=0;i<numR;i++){
        Available[i] -=Request[i];
    }
    for(i=0;i<numR;i++){
        Need[i] -=Request[i];
    }
    for(i=0;i<numR;i++){
        Allocation[i] +=Request[i];
    }
    if(isSafy()){
        cout<<"可以分配！"<<endl;
        return ;
    }else{
        cout<<"产生死锁！"<<endl;
        for(int i=0;i<numR;i++){
            Available[i] +=Request[i];
        }
        for(i=0;i<numR;i++){
            Need[i] +=Request[i];
        }
        for(i=0;i<numR;i++){
            Allocation[i] -=Request[i];
        }
    }
}