用C语言描述银行家算法，安全性算法的过程

算法简介

银行家算法是一种最有代表性的避免死锁的算法。在避免死锁方法中允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。为了实现银行家算法，在系统中必须设置这样四个数据结构，分别用来描述系统中可利用的资源、所有进程对资源的最大需求、系统中的资源分配，以及所有进程还需要多少资源的情况。

1.数据结构

(1) 可利用资源向量 Available。这是一个含有 m 个元素的数组，其中的每一个元素代表一类可利用的资源数目，其初始值是系统中所配置的该类全部可用资源的数目，其数值随该类资源的分配和回收而动态地改变。如果 Available[j] = K，则表示系统中现Rj类资源K个。
(2) 最大需求矩阵Max。这是一个n×m的矩阵，它定义了系统中n个进程中的每个进程对m类资源的最大需求。如果Max[i,j] = K，则表示进程i需要Rj 类资源的最大数目为K。
(3) 分配矩阵 Allocation。这也是一个n× m的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。如果 Allocation[i,jl = K，则表示进程i当前己分得Rj类资源的数目为K。
(4) 需求矩阵Need.这也是一个n×m的矩阵，用以表示每一个进程尚需的各类资源数。如果Need[i,j] = K，则表示进程i还需要Rj类资源K个方能完成其任务。
上述三个矩阵间存在下述关系：
$$Need[i,j]=Max[i,j]-allocation[i,j]$$

2.银行家算法描述

设 Request是进程Pi的请求向量，如果 Requesti[j] = K，表示进程Pi需要K个Rj类型的资源。当Pi发出资源请求后，系统按下述步骤进行检査:
　　(1) 如果 Requesti[j] ≤ Need[i,j]便转向步骤(2)；否则认为出错，因为它所需要的资源数已超过它所宣布的最大值。
　　(2) 如果 Requesti[j] ≤ Available[j]，便转向步骤(3)；否则，表示尚无足够资源，Pi须等待。
　　(3) 系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：
　　　　Available[j] = Available[j] - Requesti[j];
　　　　Allocation[i,j] = Allocation[i,j] + Requesti[j];
　　　　Need[i,j] = Need[i,j] - Requesti[j];
　　(4) 系统执行安全性算法，检查此次资源分配后系统是否处于安全状态。若安全，才正式将资源分配给进程Pi，以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。

3.安全性算法

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

例题

有5个进程P1、P2、P3、P4、P5共用三类资源A（17个）、B（5个）、C（20个），T0时刻系统状态如下表所示。

	最大需求	已分配	可用
P1	A=5,B=5,C=9	A=2,B=1,C=2
P2	A=5,B=3,C=6	A=4,B=0,C=2
P3	A=4,B=0,C=11	A=4,B=0,C=5
P4	A=4,B=2,C=5	A=2,B=0,C=4
P5	A=4,B=2,C=4	A=3,B=1,C=4

请问：

（1） T0时刻系统是否为安全状态？若安全请给出安全序列。

（2） T0时刻，P2：Request(0, 3, 4)，能否分配，为什么?

（3） 在（2）的基础上P4：Request(2, 0, 1)，能否分配，为什么?

（4） 在（3）的基础上P1：Request( 0, 2, 0)，能否分配，为什么?

源代码

#include
#define M 3   // 资源类别总数 
#define NUM 5   // 进程总数 
#include 
#include 
#include

int Available[M] = {
     2,3,3};        // 系统空闲资源 
int MAX[NUM][M] = {
     5,5,9,5,3,6,4,0,11,4,2,5,4,2,4};   //每个进程需要的最大资源  
int Allocation[NUM][M] = {
     2,1,2,4,0,2,4,0,5,2,0,4,3,1,4}; // 已经分配的资源 
int Need[NUM][M];  // 还需要的资源 

// 模拟加载进度条 
void loading()
{
     
	int i;
	for(i=0;i<20;i++)
	{
     
		Sleep(i*10);
		printf(".");
	}
	printf("\n");
}

// 计算Need[][] 
void need()
{
     
	int i,j;
	for(i=0; i<NUM; i++)
	{
     
		for(j=0; j<M; j++)
		{
     
			Need[i][j] = MAX[i][j] - Allocation[i][j]; 
		}
	} 	
}

// 检查申请的request是否符合要求 
int check(int pi, int Request[])
{
     
	/*
	pi -- 需要检查的进程号
	Request[] --  进程pi请求的资源向量 
	
	return flag;
	flag = 0 -- 进程pi申请的资源合理，系统有足够资源分配
	flag = 1 -- 进程Pi所请求的资源已超过它所需要的资源，请求出错 
	flag = 2 -- 进程pi请求的资源大于系统的空闲资源，等待其他资源释放 
	*/ 
	int i,j,flag = 0;
	Sleep(1000);
	printf("检查申请的资源是否合理中......\n");
	loading();
	printf("检查结果:\n\n"); 
	for(i=0;i<M;i++)
	{
     
		if(Need[pi][i] < Request[i]){
     
			printf("出错，进程P%d它所请求的R%d资源数%d已超过它所需要的最大值%d!\n",pi,i+1,Request[i],Need[pi][i]);
			flag = 1;
		}	
	}	
	if(flag == 1) return flag;
	for(i=0;i<M;i++)
	{
     
		if(Available[i] < Request[i]){
     
			flag = 2;
			printf("系统无足够资源，P%d进程等待中。\n",pi);
			break;
		}
	}
	if(flag == 0) printf("进程P%d申请的资源合理，尝试分配资源！！！\n分配成功！\n",pi);
	return flag;
}

// 安全性算法，假设所有进程按进程号顺序执行 
bool check_safe(int pi)
{
     
	int work[M],i,j,k=0,f=0;
	int safe_list[NUM+1] = {
     0};
	bool Finish[NUM];
	for(i=0;i<M;i++)
		work[i] = Available[i];
	for(i=0;i<NUM;i++)
		Finish[i] = false;
	
	while(1){
     	
		if(Finish[pi] == false){
       // 找到一个没有分配资源的进程 
			printf("\n\n查找满足工作向量R1=%d,R2=%d,R3=%d的进程...\n",work[0],work[1],work[2]);
			loading();
			for(i=0;i<M;i++){
     
				if(Need[pi][i] > work[i])  // 如果Rj没有足够资源跳出 
					break;	
			}
			if(i==M)    // i=M,表示所有Rj都有足够资源分配，则这个进程可以分配
			{
     
				printf("进程P%d满足条件,需要分配空闲资源R1=%d,R2=%d,R3=%d完成进程\n",pi,Need[pi][0],Need[pi][1],Need[pi][2]); 
				for(j=0;j<M;j++)  // 释放资源 
					work[j] = work[j] + Allocation[pi][j];
				Finish[pi] = true; 
				loading();
				printf("分配完成，工作向量为R1=%d,R2=%d,R3=%d\n",work[0],work[1],work[2]); 
				safe_list[f++] = pi;  // 存放安全序列 
				k=0;           // k=0表示扫描一轮进程后，找到了满足条件的进程 
			}
			else{
     
				printf("进程P%d申请执行，空闲资源不足！\n",pi);
				k++;    // 扫描所有进程，如果没有分配资源的进程资源不够，不能执行的进程数 
			}
		}
		pi = (pi+1)%NUM;
		if(k > NUM) // 如果k在大于NUM个不满足条件的进程还没有归零，系统必定陷入死锁 
		{
     
			printf("\n\n警告！！！\n系统进入死锁，处于不安全状态，本次的试探分配作废，恢复原来的资源分配状态.\n");
			return false;
		}
		if(f == NUM){
      // 所有的 Finish[i]都为true，找到一个安全序列
			printf("\n\n系统处于安全状态, 其中一条安全进程序列为：\n");
			for(i=0;i<NUM;i++)
				printf("p%d ",safe_list[i]);
			printf("\n");
			return true; 
		}
	}
}

void show()
{
     
	int i;
	printf("|%-15s|%-15s|%-15s|%-15s|\n","进程名","最大需求","已分配","待分配");
	printf("|%-15s|%-15s|%-15s|%-15s|\n"," ","R1  R2   R3","R1  R2   R3","R1  R2   R3");
	for(i=0; i<NUM; i++)
	{
     
		printf("|p%-14d|%-5d%-5d%-5d|%-5d%-5d%-5d|%-5d%-5d%-5d|\n",i,MAX[i][0],MAX[i][1],MAX[i][2],\
		Allocation[i][0],Allocation[i][1],Allocation[i][2],Need[i][0],Need[i][1],Need[i][2]);	
	} 
}

int main()
{
     
	//	srand(4);
	// pi -- 进程号， pi_temp 进入安全算法的试探进程号 
	int i,j=0,pi,pi_temp;
	int status;
	int Request[M];
	need(); // 计算need资源矩阵 
	while(1)
	{
     
		system("cls");
		show();
		printf("是否随机分配进程和资源(是：y):");
		if(getchar()=='y')
		{
     
			pi = rand()%NUM; // 随机选择一个进程，发出request资源请求 
			for(i=0;i<M;i++)
			{
     
				// 每个Rj随机申请资源，在这个进程的最大需求内，+2为了出现出错的情况（大于need[i]） 
				Request[i] = rand()%(Need[pi][i]+2);
			}
		}
		else
		{
     
			do{
     
				printf("请输入申请资源的进程号（0~%d）:", NUM-1);
				scanf("%d",&pi);
			}while(pi<0||pi>NUM-1);
			printf("请输入申请资源(0~100):\n");
			for(i=0;i<M;i++)
			{
     
				do{
     
					printf("R%d=",i+1);
					scanf("%d",&Request[i]);
				}while(Request[i]<0||Request[i]>100);
			} 
			
		}
		while(getchar()!='\n');  // 吸收回车符 
		loading();
		printf("进程p%d发出资源请求，R1 = %d, R2 = %d, R3 = %d\n\n",pi, Request[0], Request[1], Request[2]);
		printf("系统空闲资源R1 = %d, R2 = %d, R3 = %d\n",Available[0], Available[1], Available[2]);
		printf("试分配后系统空闲资源剩余：R1 = %d, R2 = %d, R3 = %d\n", Available[0]-Request[0], Available[1]-Request[1], Available[2]-Request[2]);
		status = check(pi,Request);   // 检查进程pi申请的资源 
		if(status == 0){
      // 如果资源足够  		    
			for(i=0; i<M; i++){
          // 尝试分配资源 
				Available[i] = Available[i] - Request[i];
				Allocation[pi][i] = Allocation[pi][i] + Request[i];
				Need[pi][i] = Need[pi][i] - Request[i];
			}
			printf("系统空闲资源R1=%d,R2=%d,R3=%d\n", Available[0], Available[1], Available[2]); 
			// 如果资源不够，pi等待，分配给下一个申请资源的进程 
			// 如果资源足够，分配资源给pi进程后，剩下的资源给下一个申请资源的进程 
			// 为了节省时间，进程申请顺序按进程号顺序 
			pi_temp = (pi + 1)%NUM;
			// 安全性算法 
			if(check_safe(pi_temp)) //如果存在安全序列，则打印相关信息 
			{
     
				printf("正在分配资源R1=%d,R2=%d,R3=%d给进程p%d\n", Request[0], Request[1], Request[2],pi);
				for(i=0;i<M;i++)
				{
     
					printf(" . ");
					Sleep(2000);
				} 
				printf("\n分配后的资源矩阵：\n");
				show();
				printf("\n分配完成！\n");
			}
			else  // 如果不存在安全序列，则撤销分配的资源 
			{
     
				printf("资源恢复中"); 
				for(i=0;i<M;i++)
				{
     
					printf(" . ");
					Sleep(2000);
				} 
				Available[i] = Available[i] + Request[i];
				Allocation[pi][i] = Allocation[pi][i] - Request[i];
				Need[pi][i] = Need[pi][i] + Request[i];
				printf("\n恢复完成！\n");
				printf("进程p%d本次分配资源失败，进入等待状态。。。\n");
			}
		}
		system("pause");
	}
}

（1）P1发出资源请求Request(0,3,4),查看能否分配，实验结果是P1进程处于等待状态，因为P1请求的资源（0,3,4）大于系统空闲的资源（2,3,3），需要等待其他进程执行完成后释放资源，使空闲资源大于P1进程请求的资源P1才能执行。

（2）在（1）的基础上P3发出资源请求Request(2,0,1),由于程序设计的是可以循环执行，（1）中P1进程由于没有足够资源，等待其他进程先执行，此时P3发出资源请求Request(2,0,1)，可以找到一个安全序列P3,P4,P0,P1,P2,所以可以分配P3发出的资源请求，分配后Allocation[3]变为(4,0,5),need[3]变为(0,2,0)


（3）在(2)的基础上P0发出资源请求Request(0,2,0),系统资源还剩下（0,1,2），扫描所有进程，发现不能满足所有进程的需要，即不能满足所有进程的 Finish[i] =true,所以不能分配资源给P0，将p0试分配的资源恢复回系统。


（4）如果 Requesti[j] > Need[i,j]时，如果进程P2申请资源(1,1,2)，这种情况是不会出现的，提示输入出错，因为P2申请的资源与已分配的资源的总和已经超过进程P2所需要的最多资源。