银行家算法

银行家算法实验

安全性算法
（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［i］+Allocation［i,j］;
Finish［i］∶=true;
go to step 2;
（4）如果所有进程的Finish［i］=true都满足， 则表示系统处于安全状态；否则，系统处于不安全状态。

安全性算法流程图

#include <iostream>
#include <string>

#define M 3   //资源的种类数
#define N 5   //进程的个数

using namespace std;

void output(int iMax[N][M],int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]);
bool safety(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]);
bool banker(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]);

void main()
{
	int i,j;

	//当前可用每类资源的资源数
	int iAvailable[M]={3,3,2};

	//系统中N个进程中的每一个进程对M类资源的最大需求
	int iMax[N][M]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};
	
	//iNeed[N][M]每一个进程尚需的各类资源数
	//iAllocation[N][M]为系统中每一类资源当前已分配给每一进程的资源数
	int iNeed[N][M],iAllocation[N][M]={{0,1,1},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};
	
	//进程名
	char cName[N]={'a','b','c','d','e'};

	bool bExitFlag=true;   //退出标记
	char ch;			   //接收选择是否继续提出申请时传进来的值
	
	bool bSafe;   //存放安全与否的标志
	//计算iNeed[N][M]的值
	for(i=0;i<N;i++)
		for(j=0;j<M;j++)
			iNeed[i][j]=iMax[i][j]-iAllocation[i][j];
		
	output(iMax,iAllocation,iNeed,iAvailable,cName);
	bSafe=safety(iAllocation,iNeed,iAvailable,cName);
	
	//是否继续
	while(bExitFlag)
	{
		cout<<"\n"<<"继续提出申请？\ny为是；n为否。\n";
		cin>>ch;

		switch(ch)
		{  
		    case 'y':
                //cout<<"调用银行家算法";
				bSafe=banker(iAllocation,iNeed,iAvailable,cName);
				if (bSafe)   //安全，则输出变化后的数据
					output(iMax,iAllocation,iNeed,iAvailable,cName);
				break;
	        case 'n': 
			    cout<<"退出。\n";
			    bExitFlag=false; 
			    break;
		    default: 
		        cout<<"输入有误，请重新输入：\n";
		}
	}
}

输出操作

void output(int iMax[N][M],int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N])
{
	int i,j;

	cout<<"\n\t   Max  \tAllocation\t  Need  \t Available"<<endl;
	cout<<"\tA   B   C\tA   B   C\tA   B   C\t A   B   C"<<endl;

	for(i=0;i<N;i++)
	{	
		cout<<cName[i]<<"\t";
		
		for(j=0;j<M;j++)
			cout<<iMax[i][j]<<"   ";
		cout<<"\t";
		
		for(j=0;j<M;j++)
			cout<<iAllocation[i][j]<<"   ";
		cout<<"\t";

		for(j=0;j<M;j++)
			cout<<iNeed[i][j]<<"   ";
		cout<<"\t";
		cout<<" ";
		
		//Available只需要输出一次
		if (i==0)
			for(j=0;j<M;j++)
				cout<<iAvailable[j]<<"   ";
					
		cout<<endl;
	}	
}

安全性检查算法

//安全性算法，进行安全性检查
bool safety(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N])
{
	//请同学们自己完成
  	int i,j,k;
	char cSafeString[N];//存放安全序列中的进程名
	int loc=0;//存放安全序列数组中的当前下标，即能顺利执行结束的进程个数
	int iWork[M];
	bool bFinish[N]={false};//定义并初始化bFinish
	for(j=0;j<M;j++)//初始化iWork
		iWork[j]=iAvailable[j];
//最大需要查找N次即在每一次查找中一次只找到一个满足条件的进程
		for(k=0;k<N;k++)
		{
			for(i=0;i<N;i++)//在一次的查找中，从头向尾查找
			{//Finish[i]=false满足
				if(!bFinish[i])
				{//判断Need[i,j]<Work[j]是否满足
					for(j=0;j<M;j++)
					{//不满足Need[i,j]<Work[j]
						if(iNeed[i][j]>iWork[j]) break;
					}
					if(j==M)
					{//释放已分配资源
						for(j=0;j<M;j++)
							iWork[j]=iWork[j]+iAllocation[i][j];
						bFinish[i]=true;
						//安全序列
						cSafeString[loc]=cName[i];
						//以执行完成的进程个数
						loc++;
					}
				}
			}
		}
		if(loc==N)//安全，则输出安全序列
		{
			cout<<"\n当前系统的一个安全序列为:\n";
			for(i=0;i<N;i++)
				cout<<" "<<cSafeString[i];
			cout<<","<<endl;
			return true;
		}
		else//不安全
			cout<<"\n系统不安全!";
		return false;
}
//定位ch对应的进程名在数组中的位置
//没找见返回-1,否则返回数组下标
int locate(char cName[N],char ch)
		{
			int i;
			for(i=0;i<N;i++)
				if(cName[i]==ch)//找到
					return i;
				return -1;
		}
//提出申请，返回提出申请的进程名对应的下标
int request(char cName[N],int iRequest[M])
		{
			int i,loc;
			char ch;
			bool bFlag=true;
			//判断输入的进程名是否有误
			while(bFlag)
			{//输出进程名
				for(i=0;i<N;i++)
					cout<<cName[i]<<"\t";
			cout<<"\n输入提出资源申请的进程名：\n";
			cin>>ch;
			//定位ch对应的进程名在进程名数组中的个位置
			loc=locate(cName,ch);
			if(loc==-1)//没找到，重新输入
				cout<<"\n您输入的进程名有误！请重新输入";
			else//找到，退出循环
				bFlag=false;
			}
			cout<<"输入申请各类资源的数量：\n";
				for(i=0;i<M;i++)
					cin>>iRequest[i];
				//返回提出申请的进程名对应的下标
				return loc;

}

bool banker(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N])
{
	//请同学们自己完成
	int i,loc;
	int iRequest[M];
	bool bFlag=true;//是否满足条件
	//提出申请，返回提出申请的进程名对应的下标
	loc=request(cName,iRequest);
	//判断是否满足request<=need
	for(i=0;i<M;i++)
	{
		if(iRequest[i]>iNeed[loc][i])
		{
			cout<<"需求申请超出最大需求值"<<endl;
			return false;
		}
	}
	for(i=0;i<M;i++)
	{
		if(iRequest[i]>iAvailable[i])
		{
			cout<<"系统没有足够资源"<<cName[loc]<<"进程阻塞"<<endl;
			return false;
		}
	}
	//系统试探着把资源分配给进程，并修改下面数据结构中的数值
	for(i=0;i<M;i++)
	{
		iAvailable[i]=iAvailable[i]-iRequest[i];
		iNeed[loc][i]=iNeed[loc][i]-iRequest[i];
		iAllocation[loc][i]=iAllocation[loc][i]+iRequest[i];
	}
	//调用安全性算法，判断当前是否安全，安全则真正分配
	//否则恢复已修改的值
	bFlag=safety(iAllocation,iNeed,iAvailable,cName);
	//不安全，恢复已修改的值
	if(!bFlag)
	{
		for(i=0;i<M;i++)
		{
		iAvailable[i]=iAvailable[i]-iRequest[i];
		iNeed[loc][i]=iNeed[loc][i]-iRequest[i];
		iAllocation[loc][i]=iAllocation[loc][i]+iRequest[i];
		}
		cout<<"进程"<<cName[loc]<<"阻塞"<<endl;
	}
	return bFlag;
}

参考资料：

1、 汤子瀛编.《计算机操作系统》.北京：西安电子科技大出版社。
2、 张尧学等编著.《计算机操作系统教程》.北京：清华大学出版社。

大佬勿喷