银行家算法C++

银行家算法数据结构

① 可利用资源向量Available[]
② 最大需求矩阵Max[][]
③ 分配矩阵Allocation[][]
④ 需求矩阵Need[][]
关系：Need[i][j]=Max[i][j]-Allocatioon[i][j]

银行家算法

设Request，是进程Pi的请求向量，如果Rquest[i][]=K,表示进程Pi需要K个R[]类型的资源。当Pi发出资源请求后，系统按下述步骤进行检查:
① 如果Requst[i][]<Need[i],便转向步骤(2);否则认为出错，因为它所需要的 资源数已超过它所宣布的最大值。
② 如果Request[i][]<Available[],便转向步骤(3); 否则，表示尚无足够资源， Pi须等待。
③ 系统试探着把资源分配给进程Pi,并修改下面数据结构中的数值:

Available[i][] = Availablel[i][] – Request[i][];

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

Need[i][] = Need[i][] – Request[i][];
④ 系统执行安全性算法，检查此次资源分配后系统是否处于安全状态。若安全，才正式将资源分配给进程Pi;,以完成本次分配;否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。

安全性算法

① 设置两个向量;
工作向量Work,它表示系统可提供给进程继续运行所需的各类资源数目，它含有m个元素，在执行安全算法开始时，Work = Available;②Finish: 它表示系统是否有足够的资源分配给进程，使之运行完成。开始时先做Finish[i]= false;当有足够资源分配给进程时，再令Finish[i] = true。
② 从进程集合中找到一个能满足下述条件的进程:
Finish[i] = false;
Need[i][ ]≤Work[];
若找到，执行步骤(3)，否则，执行步骤(4)。
③ 当进程Pi获得资源后，可顺利执行，直至完成，并释放出分配给它的资源， 故应执行:
Work[] = Work[] + Allocation[i][];
Finish[i] = true;]
Go to step (2);
④ 如果所有进程的Finish=true，则表示系统处于安全状态；否则系统不安全。

代码实现C++

#include<iostream>
using namespace std;
/*数据结构*/

int Max[5][3] = { 
	7,5,3,
	3,2,2,
	9,0,2,
	2,2,2,
	4,3,3};//最大需求矩阵
int Allocation[5][3] = {
0,1,0,
2,0,0,
3,0,2,
2,1,1,
0,0,2}; //已分配矩阵
int Need[5][3] = {
7,4,3,
1,2,2,
6,0,0,
0,1,1,
4,3,1};//需求矩阵
int Available[3] = {3,3,2};//可利用资源
int Request[5][3] = { 0 };//请求资源向量
int Work[3] = { 0 };// 存放系统可提供资源
bool Finish[5] = { false }; //标记系统是否有足够资源
int Security[5] = { 0 };//安全序列
int l = 0;//安全队列下标
int n = 5;//进程数
int m = 3;//资源数

bool victory();
bool compareW(int i);
void allocationW(int i);
void insertL(int i);
bool compareN(int i);  //比较请求资源是否小于Need资源
bool compareA(int i); //比较请求资源是否小于Available资源
void init() {   //初始化资源

	//当前进程数为5个  
	//当前有3类资源 各种资源的数量分别为10，5，7   参照书本121p的银行家算法例题
	//n = 5;
	//m = 3;
	//T0时刻状态
		//将Available赋值给Work向量
	for (int i = 0; i < m; i++) {
		Work[i] = Available[i];
	}
	//初始化Finish
	for (int i = 0; i < n; i++)
		Finish[i] = false;
	//初始化安全队列
	for (int i = 0; i < n; i++)
		Security[i] = 0;
	for(int i=0;i<n;i++)
		for (int j=0; j < m; j++) {
			Request[i][j] = 0;
		}
	l = 0;//初始化队列下标
}
bool safe() {     //安全性算法
	init();
	int i = 0;  //当前进程下标
	int execute = 0;//执行最大次数，达到最大次数则认为不安全；
	while (!victory()) {
		execute++;
		if (execute > n * n) {
			return false;
		}
		if (Finish[i] == false && compareW(i)) {
			allocationW(i);
			Finish[i] = true;
			insertL(i);
		}
		i++;
		i = i % 5;
	}
	return true;

}
bool victory() {      //判断是否全部完成Finish=true，并作为条件结束循环
	for (int i = 0; i < n; i++) {
		if (Finish[i] == false)
			return false;
	}
	return true;
}
bool compareW(int i) {   //比较进程需求是否小于工作向量
	for (int j = 0; j < m; j++) {
		if (Need[i][j] > Work[j]) {
			return false;
		}
	}
	return true;
}
void allocationW(int i) {     //分配资源给工作目录
	for (int j = 0; j < m; j++) {
	
		Work[j] = Work[j] + Allocation[i][j];
		
	}
}
void insertL(int i) {  //插入队列
	Security[l] = i;
	l++;
}


//请求资源部分
bool request() {        //请求资源
	init();
	cout << "请输入进程序号从0开始：" << endl;
	int i;//记录输入的进程号
	cin >> i;
	cout << "请输入各类资源需求数量：(用空格隔开):" << endl;
	for (int j = 0; j < m; j++) {
		cin >> Request[i][j];
	}

	if (compareN(i) && compareA(i)) {   //预分配资源
		for (int j = 0; j < m; j++) {
			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 (safe()) {
			cout << "分配成功" << endl;
			return true;
		}
		else
		{
			for (int j = 0; j < m; j++) {
				Available[j] = Available[j] + 2*Request[i][j];
				Allocation[i][j] = Allocation[i][j] - 2*Request[i][j];
				Need[i][j] = Need[i][j] + 2*Request[i][j];
			}
		}
	}
	return false;
}
bool compareN(int i) {   //比较请求资源是否小于Need资源
	for (int j = 0; j < m; j++) {
		if (Request[i][j]>Need[i][j]) {
			return false;
		}
	}
	return true;
}
bool compareA(int i) {   //比较请求资源是否小于Available资源
	for (int j = 0; j < m; j++) {
		if (Request[i][j] > Available[j]) {
			return false;
		}
	}
	return true;
} 

//打印部分
void printStatus() {       //打印当前状态
	int i, j;
	cout << "进程\\资源" << ' ' << "   Max   " << ' ' << "Allocaion" << ' ' << "  Need   " << ' ' << "Available" << endl;
	cout << "         " << ' ' << " A  B  C " << ' ' << " A  B  C " << ' ' << " A  B  C " << " A  B  C " << endl;
	for (i = 0; i < n; i++) {
		cout << "   P" << i << "    " << ' ';
		for (j = 0; j < m; j++) {     //Max
			cout << ' ' << Max[i][j] << ' ';
		}
		cout << ' ';
		for (j = 0; j < m; j++) {     //Allocation
			cout << ' ' << Allocation[i][j] << ' ';
		}
		cout << ' ';
		for (j = 0; j < m; j++) {     //Need
			cout << ' ' << Need[i][j] << ' ';
		}
		if (i == 0) {
			for (j = 0; j < m; j++) {     //Available
				cout << ' ' << Available[j] << ' ';
			}
			cout << ' ' << endl;
		}
		else
		{
			cout << endl;
		}
	}
}
void printSLink() {   //打印安全队列
	cout << "当前安全队列为：" << endl;
	for (int i = 0; i < n; i++) {
		if (i == n - 1)
			cout << "P" <<Security[i] << endl;
		else 
			cout << "P"<< Security[i] << "->";
		
	}
	
}
//test测试
/*int main() {
	printStatus();
	safe();
	printSLink();
}*/
int main() {
	int c=10;
	
	while (c!=4){	
		cout << endl;
		cout << endl;
		printStatus();
		cout << "1.打印当前资源状态" << endl;
		cout << "2.请求资源" << endl;
		cout << "3.打印安全队列" << endl;
		cout << "4.退出" << endl;
		cout << "请输入指令：" << endl;
		cin >> c;system("cls");
		switch (c) {
		
		case 1:printStatus(); break;
		case 2:if (request()) { printStatus(); printSLink(); }
			  else { cout << "分配资源失败" << endl; }
			  break;
		case 3:if (safe()) { 
			printStatus; printSLink(); break; }
			  else {
			cout << "当前状态不安全，没有安全队列" << endl;
			break;
		}
		}
	}

}

运行效果

图片: 未执行操作
执行2请求资源

请求资源失败

参考文献：汤小丹、梁红兵、哲凤屏、汤字瀛 .2014.计算机操作系统.西安 电子科技大学出版社.440pp.