#学志#银行家算法

我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。
为保证资金的安全,银行家规定:

(1) 当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客;

(2) 顾客可以分期贷款,但贷款的总数不能超过最大需求量;

(3) 当银行家现有的资金不能满足顾客尚需的贷款数额时,对顾客的贷款可推迟支付,但总能使顾客在有限的时间里得到贷款;

(4) 当顾客得到所需的全部资金后,一定能在有限的时间里归还所有的资金；

数据结构：

1. 当前系统的可利用资源available[]；

2. 进程所占有的资源allocation[];

3. 进程所需的最大的资源数max[]；

4. 当前进程需要的资源数need[];

最终需要得到所有可能的结果。

代码：

#include <iostream>
#include <fstream>
#define MAX 100
using namespace std;
struct process{
string name;//进程名字
int allcolation[MAX] = {0};//进程已占用的资源量
int max[MAX] = {0};//进程最大所需的资源量
int need[MAX] = {0};//进程还需要的资源量
int finish = 0;//该进程是否已经申请过资源
};
//当前系统可利用资源
process p[MAX];//进程信息
int sequence[MAX];//可能情况的队列
int a[MAX];//可利用资源数量
int i = 0;//进程的数量
int sourceNum;//资源的种类
int count = 1;//所有情况的数量

ifstream inFile("process.txt");//进程信息输入文件
ofstream outFile("sequence.txt");

void processFinished(int j);//计算结果函数

int main(){
//读取数据
//资源信息
inFile>>sourceNum;
outFile<<"The type of resources: "<<sourceNum<<endl;
outFile<<"The resources: ";
for(int j = 0; j < sourceNum; j++){
inFile>>a[j];
outFile<<a[j]<<" ";
}
outFile<<endl;
//进程信息
while(!inFile.eof()){
inFile>>p[i].name;
for(int j = 0; j < sourceNum; j++){
inFile>>p[i].allcolation[j];
a[j] -= p[i].allcolation[j];//现可用资源为所有资源减去被占有的资源
}
for(int j = 0; j < sourceNum; j++){
inFile>>p[i].max[j];
p[i].need[j] = p[i].max[j] - p[i].allcolation[j];
}
i++;
}
for(int j = 0; j < i; j++){
cout<<p[j].name<<" ";
for(int k = 0; k < sourceNum; k++){
cout<<p[j].allcolation[k]<<" ";
}
for(int k = 0; k < sourceNum; k++){
cout<<p[j].max[k]<<" ";
}
for(int k = 0; k < sourceNum; k++){
cout<<p[j].need[k]<<" ";
}
cout<<endl;
}
outFile<<"----------All results----------"<<endl;
processFinished(0);

return 0;
}
//参数j为结果步骤情况，即该进程第j个被执行
void processFinished(int j){
int a2[sourceNum];
for(int t = 0; t < sourceNum; t++){
a2[t] = a[t];
}
//将当下满足的所有进程放入一个等待的队列
int wait[MAX];
int w = 0;//等待队列的数量
for(int k = 0; k < i; k++){
//判断该进程是否能被下步操作，可以存入等待队列
if(!p[k].finish){
int flag = 0;//是否可为下步操作的标识
for(int t = 0; t < sourceNum; t++){
if(p[k].need[t] > a[t]){
flag = 1;
}
}
if(!flag){
wait[w++] = k;
}
}
}
//完成等待队列的内容
for(int k = 0; k < w; k++){
for(int t = 0; t < sourceNum; t++){
a[t] = a[t] - p[wait[k]].need[t] + p[wait[k]].max[t];
}
p[wait[k]].finish = 1;
//添加到结果队列
sequence[j] = wait[k];//当前执行的进程
//是否所有进程都完成
if(j == (i - 1)){
//所有进程完成输出结果
outFile<<"case "<<count++<<"\t: ";
for(int j = 0; j < i; j++){
outFile<<p[sequence[j]].name<<" ";
}
outFile<<endl;
//在返回时将自身的改变信息消除
p[wait[k]].finish = 0;
//可利用的资源也返回上一步
for(int j = 0; j < sourceNum; j++){
a[j] = a2[j];
}
return;
}
else{
processFinished(j + 1);
//消除当前情况的改变
//恢复到到达该步时的状态，进行下一种情况的判断
p[wait[k]].finish = 0;
for(int t = 0; t < sourceNum; t++){
a[t] = a2[t];
}

}
}
}

文件：

1.

4 10 5 7 12

p0 0 1 0 2 7 5 3 2

p1 2 0 0 3 3 2 4 4

p2 3 0 2 0 6 1 2 1

p3 2 1 1 0 2 2 2 5

p4 0 0 2 1 2 3 3 8

p5 1 0 0 0 5 2 6 6

2.

3 10 5 7

p0 0 1 0 7 5 3

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

结果：