C++实现银行家算法

银行家算法

申请者事先说明对各类资源的最大需求量。在进程活动期间动态申请某类资源时，由系统审查系统现有该类资源的数目是否能满足当前进程的最大需求量，如能满足就予以分配，否则拒绝。

银行家算法中的数据结构

(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,j]=K，则表示进程i当前已分得Rj类资源的数目为K。
(4) 需求矩阵Need。这也是一个n×m的矩阵，用以表示每一个进程尚需的各类资源数。如果Need[i,j]=K，则表示进程i还需要Rj类资源K个，方能完成其任务。
上述三个矩阵间存在下述关系：
Need[i, j]=Max[i, j]-Allocation[i, j]

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

系统所执行的安全性算法可描述如下：
　　(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；
go to step （2）；

(4) 如果所有进程的Finish[i]=true都满足，则表示系统处于安全状态；否则，系统处于不安全状态。

实例

假定系统中有五个进程{P0，P1，P2，P3，P4}和三类资源{A，B，C}，各种资源的数量分别为10、5、7，在T0时刻的资源分配情况如图示。

实现

#include<iostream>
#include<math.h>
#include<string>
using namespace std;

//#define P 5;//5个进程
//#define R 3;//三类资源
int AR[3]={10,5,7};//各类资源的总数量
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];//需求矩阵
int Request[3];//申请资源请求
int Avaliable[3];//可用资源量
void Display()
{
	cout<<"Allocation：各进程已分配的资源量"<<endl;
	cout<<"          A     B     C"<<endl;
	for(int i=0;i<5;i++)
	{
		cout<<"进程P"<<i<<"    ";
		for(int j=0;j<3;j++)
		{
			cout<<Allocation[i][j]<<"     ";
		}
		cout<<endl;
	}
	cout<<endl;
	cout<<"Need：各进程还需要的资源量"<<endl;
	cout<<"          A     B     C"<<endl;
	for(int i=0;i<5;i++)
	{
		cout<<"进程P"<<i<<"    ";
		for(int j=0;j<3;j++)
		{
			cout<<Need[i][j]<<"     ";
		}
		cout<<endl;
	}
	cout<<endl;
	cout<<"Avaliable:可用资源量"<<endl;
	cout<<"A     B     C"<<endl;
	for(int i=0;i<3;i++)
		cout<<Avaliable[i]<<"     "; 
	cout<<endl;
	
}
int Security(int s)
{
	int Finish[5];
	for(int j=0;j<5;j++)
		Finish[j]=false;
	int Work[3];
	for(int i=0;i<3;i++)
		Work[i]=Avaliable[i];
	int m=s;
	int n=1;
	if(Finish[m]==false&&(Need[m][0]>Work[0]||Need[m][1]>Work[1]||Need[m][2]>Work[2]))
	{
		for(m=0;m<5;m++)
		{
			if(Finish[m]==false&&Need[m][0]<=Work[0]&&Need[m][1]<=Work[1]&&Need[m][2]<=Work[2])
			{
				for(int i=0;i<3;i++)
		        Work[i]=Work[i]+Allocation[m][i];
		        Finish[m]=true;
				break;
			}
			
		}
		if(m==5) {cout<<endl<<"系统不安全，资源申请不成功！"<<endl;return 1;}
		m=0;
		do
	{
	if(Finish[m]==false&&Need[m][0]<=Work[0]&&Need[m][1]<=Work[1]&&Need[m][2]<=Work[2])
	{
		for(int i=0;i<3;i++)
		Work[i]=Work[i]+Allocation[m][i];
		Finish[m]=true;
		m=0;
		n=0;
	}
	else
		m++;
	
	}while(m<5);
	for(int i=0;i<5;i++)
			if(Finish[i]==false)
			{
				cout<<endl<<"系统不安全，资源申请不成功！"<<endl;
				return 1;
			}
    cout<<endl<<"系统安全，资源分配成功！"<<endl;
	return 0;
	}
	do
	{
	if(Finish[m]==false&&Need[m][0]<=Work[0]&&Need[m][1]<=Work[1]&&Need[m][2]<=Work[2])
	{
		for(int i=0;i<3;i++)
		Work[i]=Work[i]+Allocation[m][i];
		Finish[m]=true;
		m=0;
		n=0;
	}
	else
		m++;
	
	}while(m<5);
	for(int i=0;i<5;i++)
			if(Finish[i]==false)
			{
				cout<<endl<<"系统不安全，资源申请不成功！"<<endl;
				return 1;
			}
    cout<<endl<<"系统安全，资源分配成功！"<<endl;
	return 0;
	
}
void Bank()
{
	int key=1;
	cout<<"请输入请求资源的进程号：";
	string s;
	cin>>s;
	int i=s[1]-'0';
	cout<<"请输入进程"<<s<<"申请的资源量：";
	cin>>Request[0]>>Request[1]>>Request[2];
	for(int j=0;j<3;j++)
	{
		if(Request[j]>Avaliable[j])
	    {
			cout<<"进程申请的资源量大于现有资源总量，申请失败！"<<endl;
			key=0;
			break;
		}
		else if(Request[j]>Need[i][j])
		{
			cout<<"进程申请的资源量大于所需资源总量，申请失败！"<<endl;
			key=0;
			break;
		}
    }
	if(key==1)
	{
		for(int j=0;j<3;j++)
		{
			Avaliable[j]=Avaliable[j]-Request[j];
			Allocation[i][j]=Allocation[i][j]+Request[j];
			Need[i][j]=Need[i][j]-Request[j];
		}
		if(Security(i)==0)//系统安全
			Display();
		else//系统不安全
		{
			for(int j=0;j<3;j++)
		{
			Avaliable[j]=Avaliable[j]+Request[j];
			Allocation[i][j]=Allocation[i][j]-Request[j];
			Need[i][j]=Need[i][j]+Request[j];
		}
			Display();
		}
	}
}
void main()
{
	for(int i=0;i<5;i++)
	    for(int j=0;j<3;j++)
			Need[i][j]=Max[i][j]-Allocation[i][j];
	
	for(int i=0;i<3;i++)
	{
		int a=0;
		for(int j=0;j<5;j++)
		{
			a+=Allocation[j][i];
        }
		Avaliable[i]=AR[i]-a;
	}
	Display();
	int run=1;
	while(run)
	{
		Bank();
		cout<<endl;
		cout<<"是否继续银行家算法，是1，否0：";
		cin>>run;
	}
	system("pause");
}

结果

感想

银行家算法的实现比我想象中的要难，我觉得难点就在于安全性检测上，刚开始的时候，我的思路是往资源申请成功方面上写的，然后比较容易的实现了进程进行一次申请并且成功的过程。但是后来我发现在第一次进程申请资源成功后，另一个进程继续申请资源后出现了很多种情况，特别是当进程申请后的资源仍然无法满足Need，这时候进行安全性检测就会变得复杂一些，后来我便根据这种情况对算法进行了改进。