一.银行家算法

1.由来

银行家算法最初是由荷兰计算机科学家艾兹赫尔·迪杰斯特拉（Edsger W. Dijkstra）于1965年提出的。当时他正致力于解决多道程序设计中产生的死锁问题。在多道程序设计中，由于不同进程之间共享有限的系统资源，如内存、I/O设备等，因此存在一个进程等待其他进程释放资源而导致所有进程都无法执行完毕的情况，称为死锁。为了避免死锁的发生，需要一种能够动态地分配和撤销资源的方法。

银行家算法就是针对这个问题而提出的一种资源分配算法。它基于资源分配图和安全序列的概念，通过动态计算系统当前的安全状态来判断是否可以分配资源，并且仅在分配后不会导致死锁的情况下执行分配。银行家算法成为了解决死锁问题的经典算法之一，在操作系统中得到广泛应用，并且也启发了许多后来的研究工作。

2.介绍

银行家算法是一种用于避免死锁的经典算法，通常应用于操作系统中。该算法通过检查资源分配状态来判断是否可以满足进程的请求，并且仅在满足所有进程请求时才执行分配。以此来保证系统不会陷入死锁。

银行家算法的基本思想是，在计算机系统中，对于每种资源都设置一个最大需求量和当前可用量，当一个进程提出资源请求时，系统首先检查该进程是否满足其最大需求量限制，如果请求合法，则尝试分配资源给该进程并检查是否会导致系统进入不安全状态（即可能发生死锁），如果不会，则分配资源；否则，拒绝该进程的请求。具体实现中，通常使用银行家算法数据结构来记录每个进程的最大需求量、已分配数量和当前需要数量等信息，以及每种资源的总量和可用数量等信息。根据这些信息，可以动态地计算系统当前的安全状态，从而有效地避免死锁的发生。

二.基本原理

1.文字理解

银行家算法的原理基于资源分配图和安全序列。

在银行家算法中，每个进程有一个最大需求量向量、一个已分配资源向量和一个当前需要的资源向量。系统也有一个可用资源向量和一个总资源向量。当一个进程请求一定数量的资源时，系统必须确定这个请求是否能被满足，并在不进入死锁状态的前提下将资源分配给该进程。

为了检查是否能够满足该请求并避免死锁，银行家算法实现了安全性检查机制。安全性检查机制会计算出所有未满足进程的最大需求量和当前需要量之和（即还需要的资源），然后尝试找到一个安全序列，如果可以找到安全序列，则说明该请求可以被满足而不会导致死锁。

安全序列是指一个进程执行完毕并释放它所占用的所有资源后，系统能够满足所有其他进程的最大需求量和当前需要量之和的一个序列。如果能够找到安全序列，则说明当前状态是安全的，可以分配资源给请求进程；否则，该请求就不能被满足，应该等待资源。

因此，银行家算法的原理是根据资源分配情况动态地计算系统的安全状态，从而决定是否分配资源，以避免死锁的发生。

2.程序设计基本图

3.安全算法原理

三.重要部分功能及实现

1.初始化变量定义

说明:如果我们改变资源种类和进程数量，可以在源代码开始定义变量处改变宏定义p，s的值，后续代
码的p,s的值也随之改变。如果我们采取读取文件的方法，我们可以分别建立一个资源种类和进程的.txt
文档读入，然后统计其数量赋给p，s变量。

/*Author：Cnkizy
数据参考 P121 4.银行家算法之例
*/
#include<stdio.h>
#define Pcount 5 //5个进程
#define Scount 3 //3类资源
int Available[Scount];//可利用资源向量
int Max[Pcount][Scount];//最大需求矩阵 可以通过Need+Allocation算出来
int Allocation[Pcount][Scount];//分配矩阵
int Need[Pcount][Scount];//需求矩阵
//int SouresMax[Scount] = { 10,5,7 };//这里给ABC三类资源的数量为10,5,7
/*资源分配表,必要的一些数据如下
	Max		Allocation	Need	Available
	P0		0 1 0		7 4 3	3 3 2
	P1		2 0 0		1 2 2
	P2		3 0 2		6 0 0
	P3		2 1 1		0 1 1
	P4		0 0 2		4 3 1
*/

2.计算最大需求量

说明:根据题意关系我们可知，最大资源需求量可以有已分配资源量和仍需求资源量求出。这样我们可
以减少读取最大资源需求量的文件操作。

//计算最大需求数量
void CalcMax() {
	for (int i = 0; i < p; i++) {
		for (int j = 0; j < s; j++) {
			Max[i][j] = Need[i][j] + Allocation[i][j];
		}
	}
}

3.初始化数据

说明:这里我们通过三次文件读取操作，分别将存有已分配资源数量、仍需求资源数量、待分配资源数
量分别存入其数组中，并调用计算最大需求量函数计算出最大资源需求量，完成数据初始化。

//初始化数据,资源分配表
void InitializeData() {
	//读取已分配资源
	int b[100];
	FILE* fp;
	fp = fopen("Allocation.txt", "r");
	if (fp == NULL) {
		printf("file is error.");
		return -1;
	}
	for (int j = 0; j < 15; j++) {
		fscanf(fp, "%d", &b[j]);
	}
	fclose(fp);
	int k = 0;
	for (int j = 0; j < p; j++) {
		for (int i = 0; i < s; i++) {
			Allocation[j][i] = b[k];
			k++;
		}
	}
	//读取仍需求资源
	int a[100];
	FILE* fpread;
	fpread = fopen("need.txt", "r");
	if (fpread == NULL) {
		printf("file is error.");
		return -1;
	}
	for (int j = 0; j < 15; j++) {
		fscanf(fpread, "%d", &a[j]);
	}
	fclose(fpread);
	int m = 0;
	for (int j = 0; j < p; j++) {
		for (int i = 0; i < s; i++) {
			Need[j][i] = a[m];
			m++;
		}
	}
	//读取待分配资源
    int c[100];
	FILE* fpr;
	fpr = fopen("Available.txt", "r");
	if (fpr == NULL) {
		printf("file is error.");
		return -1;
	}
	for (int j = 0; j < 15; j++) {
		fscanf(fpr, "%d", &c[j]);
	}
	fclose(fpr);
	int n = 0;
	for (int j = 0; j < p; j++) {
		for (int i = 0; i < s; i++) {
			Available[j][i] = c[n];
			n++;
		}
	}
	CalcMax();
}

4.显示当前资源分配

说明：这里我们建立一个函数来显示当前资源分配情况，方便阅读，以免我们分配资源时没有可视化的数据情况，从而出现错误。

//查看当前资源分配表
void ShowData(int line) {
	printf("	Max	Alloca	Need	Available\n");
	for (int i = 0; i < p; i++) {
		printf("p%d:\t", i);
		for (int j = 0; j < s; j++) {
			printf("%d ", Max[i][j]);
		}
		printf("\t");
		for (int j = 0; j < s; j++) {
			printf("%d ", Allocation[i][j]);
		}
		printf("\t");
		for (int j = 0; j < s; j++) {
			printf("%d ", Need[i][j]);
		}

		if (line == i) {
			printf("\t");
			for (int j = 0; j < s; j++) {
				printf("%d ", Available[j]);
			}
		}

		printf("\n");
	}

}

5.安全型算法

说明：这里写的是银行家算法里面最重要的部分安全性检测算法，首先我们设置两个向量：工作向量Work，表示系统可提供给进程继续运行所需的各类资源数目，它含有m个元素，当执行安全算法开始时，Work=Available；Finish，表示系统是否有足够的资源分配给进程，使之完成运行。开始时先使Finish[i]=false，当有足够的资源分配给进程时，再令Finish[i]=true。

//向量相加 a = a+b
void Add(int* a, int b[s]) {
	for (int i = 0; i < s; i++) {
		a[i] = a[i] + b[i];
	}
}
//向量相减 a = a-b
void Minus(int* a, int b[s]) {
	for (int i = 0; i < s; i++) {
		a[i] = a[i] - b[i];
	}
}

//资源比较   a<=b 返回1     a>b 返回0
int Equals(int a[s], int b[s]) {
	for (int i = 0; i < s; i++) {
		if (a[i] > b[i]) return 0;
	}
	return 1;
}

//检查标志所有都为True，是返回1 不是返回0
int CheckFinish(int Finish[p]) {
	for (int i = 0; i < p; i++) {
		if (Finish[i] == 0) return 0;
	}
	return 1;
}
//安全性算法,当前是否处于安全状态
int CheckSafe() {
	printf("开始安全性检查(输出一个安全序列）:\n");
	//步骤1 设置两个向量
	int Finish[p] = { 0 };//是否被处理过，初始值全为False，被检查过才置为True
	int Work[s] = { 0 };//工作向量	
	Add(Work, Available);//首先让Work = Available
	//步骤2 从进程集合寻找符合下列条件的进程
	//Finish[i] =  false;
	//Need[i,j] <= Work[j];
	for (int i = 0; i < p; i++) {
		if (Finish[i])continue;//已经标记为True就跳过
		if (!Equals(Need[i], Work))continue;//Need[i,j] > Work[j] 就跳过。
		//上述条件成立，执行步骤3
		Add(Work, Allocation[i]);//Work += Allocation;
		Finish[i] = 1;//Finish[i]=True;	
		printf("P%d进程,Work=%d %d %d,Finish=true,安全状态\n", i, Work[0], Work[1], Work[2]);
		i = -1;//返回步骤2
	}
	//步骤4 判断Finish
	if (CheckFinish(Finish)) {
		printf("安全状态检查完毕:【Finish全为true,系统处于安全状态】\n");
		return 1;//全为True		
	}
	printf("安全状态检查完毕:【Finish存在False,系统处于不安全状态】\n");
	return 0;//存在False
}

6.资源请求

说明：这里我们写的是申请资源函数，对于某个进程的资源申请，系统首先检测申请资源的进程要求是否合理，如果不合理会驳回要求，如果合理系统会先模拟把该进程申请的资源分配给该资源，然后对这种情况进行安全算法检测，如果存在一个安全序列，系统则会满足该进程的要求，然后显示当前资源分配情况。

//带命令提示符提示的请求
void RequestShowMsg(int P, int R[s]) {
	//进程P 申请资源Request{1,0,2}
	printf("\n模拟分配资源：P%d申请资源 %d %d %d\n======================\n",P, R[0], R[1], R[2]);
	int State = Apply(P, R);
	if (State) {
		printf("本次资源分配成功！\n");
		ShowData(0);
	}else {
		printf("本次资源分配失败！进程P%d需要等待\n",P);
	}
}
//进程资源请求函数， P:进程i, r申请资源数{1,1,1}     返回1成功 0失败
int Apply(int P, int Request[s]) {
	printf("进程P%d申请资源%d %d %d:\n", P, Request[0], Request[1], Request[2]);
	//步骤1 进行资源检查Request <= Need才能执行步骤2
	if (!Equals(Request, Need[P])) {
		printf("进程P%d,Request:%d %d %d > Need:%d %d %d 申请失败,所需资源数超过宣布最大值！\n", P, Request[0], Request[1], Request[2], Need[P][0], Need[P][1], Need[P][2]);
		return 0;
	}
	//步骤2 进行资源检查Request <= Available才能执行步骤3
	if (!Equals(Request, Available)) {
		printf("进程P%d,Request:%d %d %d > Available:%d %d %d 申请失败,尚无足够资源，该进程需要等待！\n", P, Request[0], Request[1], Request[2], Available[0], Available[1], Available[2]);
		return 0;
	}
	printf("进程P%d,Request:%d %d %d <= Need:%d %d %d\n", P, Request[0], Request[1], Request[2], Need[P][0], Need[P][1], Need[P][2]);
	printf("进程P%d,Request:%d %d %d <= Available:%d %d %d \n", P, Request[0], Request[1], Request[2], Available[0], Available[1], Available[2]);
	//步骤3 试分配资源给进程P
	Minus(Available, Request);//Available -= Request
	Add(Allocation[P], Request); //Allocation += Request
	Minus(Need[P], Request);//Need -= Request
	//步骤4 安全性检查
	int Safestate = CheckSafe();
	if (Safestate) {
		return Safestate;//分配后处于安全状态 分配成功
	}
	//分配后处于不安全状态 分配失败，本次分配作废，回复原来的资源分配状态
	Add(Available, Request);         //Available += Request
	Minus(Allocation[P], Request);   //Allocation -= Request
	Add(Need[P], Request);          //Need += Request
	return Safestate;
}

四.各部分实现结果

1.文件内容展示

2.初始化数据显示

3.进行安全算法

4.模拟资源申请

五.实验总结

多个进程同时运行时，系统根据各类系统资源的最大需求和各类系统的剩余资源为进程安排安全序列，使得系统能快速且安全地运行进程，不至发生死锁。银行家算法是避免死锁的主要方法，其思路在很多方面都非常值得我们来学习借鉴。

六.补充

本次博客可以看作是上一篇博客关于避免死锁的补充。多线程