银行家算法实现（操作系统实验）

最新推荐文章于 2023-10-23 20:15:14 发布

阿阿阿扶

最新推荐文章于 2023-10-23 20:15:14 发布

阅读量1.9k

点赞数 3

分类专栏：操作系统文章标签：算法蓝桥杯 c++

本文链接：https://blog.csdn.net/m0_53112875/article/details/124937012

版权

操作系统专栏收录该内容

3 篇文章 0 订阅

订阅专栏

#include <string.h>
#include<iostream.h>
#define FALSE 0
#define TRUE 1
#define W 10
#define R 20

int M;
int N;
int ALL_RESOURCE[W];
int AVAILABLE[R];
int MAX[W][R];
int ALLOCATION[W][R];  //分配矩阵
int NEED[W][R];        //需求矩阵
int Request[R];
void inputdata();
void showdata();
void changedata(int k);
void restoredata(int k);
int checksec(int s);
int checkmax(int s);
void bank();

void main()
{

  int j,i;
  inputdata();
  for(i=0;i<M;i++)
  {
   j=checksec(i);
   if(j==0)break;
  
  }
   if(i>=M)
	   cout<<"错误提示，系统的初始状态不安全"<<endl;
   else{
	   cout<<"提示：系统的初始状态安全"<<endl;
	   bank();
   }
}
void inputdata()
{
  int i=0,j=0,p;
  cout<<"请输入总进程数"<<endl;
  do{
    cin>>M;
	if(M>W)
		cout<<"总进程数超过了程序允许的最大进程数，请重新输入： "<<endl;
  }while(M>W);
  cout<<endl;
  cout<<"请输入资源的种类数："<<endl;
  do{
	  cin>>N;
	  if(N>R)
		  cout<<"资源的种类数超过了程序允许的最大资源种类数，请重新输入： "<<endl;

  
  }while(N>R);
  cout<<"请输入各类资源的总数量"<<endl;
  for(i=0;i<N;i++)
	  cin>>ALL_RESOURCE[i];
  cout<<endl;
  cout<<"请输入各进程所需要的最大资源数量，max矩阵"<<endl;
  for(i=0;i<M;i++)
  {
    for(j=0;j<N;j++)
	{
		do{
		  cin>>MAX[i][j];
		  if(MAX[i][j]>ALL_RESOURCE[j])
			  cout<<"该最大资源数量超过其声明的该资源总数，请重新输入： "<<endl;
		} while(MAX[i][j]>ALL_RESOURCE[j]);
		
	
	}
  
  }
  cout<<endl<<"输入该时刻各进程已经占据的各类资源数量"<<endl;

  for(i=0;i<M;i++)
  {
    for(j=0;j<N;j++)
	{
		do{
		  cin>>ALLOCATION[i][j];
		  if(ALLOCATION[i][j]>MAX[i][j])
			  cout<<"已占有的资源数量超过了声明的最大资源数，请重新输入： "<<endl;
		} while(ALLOCATION[i][j]>MAX[i][j]);
		
	
	}
	
  
  }
  cout<<endl;
  for(i=0;i<M;i++)
	  for(j=0;j<N;j++)
		  NEED[i][j]=MAX[i][j]-ALLOCATION[i][j];//need矩阵计算

  for(j=0;j<N;j++)
  {     
      p=ALL_RESOURCE[j];
	  for(i=0;i<M;i++)
	  {  p=p-ALLOCATION[i][j];//剩余资源计算
	     AVAILABLE[j]=p;
		 if(AVAILABLE[j]<0)
			 AVAILABLE[j]=0;
	  }
  }
  


}
void showdata()
{
	int i,j;
	cout<<"各种资源的总数量为： "<<endl;
	for(j=0;j<N;j++)
		cout <<"资源"<<j<<" : "<<ALL_RESOURCE[j]<<" ";
	cout<<endl;
	cout<<"当前各类资源可用量："<<endl;
    for(j=0;j<N;j++)
		cout <<"资源"<<j<<" : "<<AVAILABLE[j]<<" ";
	cout<<endl;
	cout<<"各进程还需矩阵矩阵为： "<<endl;
	for(i=0;i<M;i++){
	   cout<<"进程P"<<i<<": ";
	   for(j=0;j<N;j++)
		   cout<<NEED[i][j]<<"   ";
	   cout<<endl;
	}
    cout<<endl;
	cout<<"各进程已经得到的资源矩阵为： "<<endl;
	for(i=0;i<M;i++){
	   cout<<"进程P"<<i<<": ";
	   for(j=0;j<N;j++)
		   cout<<ALLOCATION[i][j]<<"   ";
	   cout<<endl;
	}
	cout<<endl;


}
void show(){
	int i,j;
    cout<<"当前各类资源可用量："<<endl;
    for(j=0;j<N;j++)
		cout <<"资源"<<j<<" : "<<AVAILABLE[j]<<" ";
	cout<<endl;
	cout<<"各进程还需矩阵矩阵为： "<<endl;
	for(i=0;i<M;i++){
	   cout<<"进程P"<<i<<": ";
	   for(j=0;j<N;j++)
		   cout<<NEED[i][j]<<"   ";
	   cout<<endl;
	}
    cout<<endl;

}

void changedata(int k)
{
  int j;
  for(j=0;j<N;j++)
  {
    AVAILABLE[j]=AVAILABLE[j]-Request[j];
	ALLOCATION[k][j]=ALLOCATION[k][j]+Request[j];
	NEED[k][j]=NEED[k][j]-Request[j];
  }
}


void restoredata(int k)
{
  int j;
  for(j=0;j<N;j++)
  {
    AVAILABLE[j]=AVAILABLE[j]+Request[j];
	ALLOCATION[k][j]=ALLOCATION[k][j]-Request[j];
	NEED[k][j]=NEED[k][j]+Request[j];
  }
}

int checksec(int s)
{  
	 int FINISH[W];
	 int i,j;
	 int replace[R];
	 
	for(j=0;j<N;j++)
	replace[j]=AVAILABLE[j];
	 
	 for(i=0;i<M;i++)
		 FINISH[i]=FALSE;
	 
	 int k=M;
	 while(k--)
	{
	 for(i=0;i<M;i++)
	 {
         if(FINISH[i]==FALSE)
		 {
			 int x=1;
			 for(j=0;j<N;j++)
			 {
              
			  if(NEED[i][j]>replace[j])
			  { x=0;break;}
			 }
		   
			 if(x==1){FINISH[i]=TRUE;
			 for(j=0;j<N;j++)
			 {
			 replace[j]+=ALLOCATION[i][j];
			 }
			
			 cout<<"P"<<i<<"  ";  
			 }

		 }
	 }
}
     int judge=1;
	 for(i=0;i<M;i++)
		 if(FINISH[i]==FALSE)
		 { judge=0;
		 cout<<"该状态不安全"<<endl;
		 return 1;}
	if(judge==1)cout<<"该状态安全"<<endl;
	show();
	return 0;

}
/*	 for(i=0;i<M;i++){
		 if()
		 for(j=0;j<N;j++){
	    WORK=AVAILABLE[j];
		if (NEED[i][j]>=WORK)

		 }
	 }
	 for(j=0;j<N;j++)
	 {
	     WORK=AVAILABLE[j];
		 i=s;
		 do
		 {  
			 if(FINISH[i]==FALSE&&NEED[i][j]<=WORK)
			 {
			    WORK=WORK+ALLOCATION[i][j];
				FINISH[i]=TRUE;
				i=0;
			 }
			 else
			 { 
				 i++;
			 
			 }
		 
		 }while(i<M);
		 for(i=0;i<M;i++)
			 if(FINISH[i]=FALSE)
			 { return 1;}	 
	 }
*/

int checkmax(int s)
{ int j,flag=1;
  for(j=0;j<N;j++)
  {
	  if(MAX[s][j]>ALLOCATION[s][j])
	  { flag=0;
	    //AVAILABLE[j]=AVAILABLE[j]+MAX[s][j];
	//	MAX[s][j]=0;
	  }	 
  } 
  if (flag==1){
	  for(j=0;j<N;j++){
	  AVAILABLE[j]=AVAILABLE[j]+MAX[s][j];
       MAX[s][j]=0;
	  }
  
  }
  return flag;
}

void bank()
{

   int i=0,j=0;
   char flag='Y';
   while(flag=='Y'||flag=='y')
   {
       i=-1;
	   while(i<0||i>=M)
	   {
	      cout<<"请输入需申请资源的进程号（从P0到P"<<M-1<<",否则重新输入：";

		  cout<<"p";
		  cin>>i;
		  if(i<0||i>=M)
			  cout<<"输入的进程号不存在，请重新输入"<<endl;

	   }
       cout<<"请输入进程P"<<i<<"申请的资源数："<<endl;
	   for(j=0;j<N;j++)
	   {
	   cout<<"资源"<<j<<":";
       cin>>Request[j];

	     if(Request[j]>NEED[i][j])
		 {
	        cout<<"进程 P"<<i<<" 申请的资源数大于系统可用"<<i<<"还需要"<<j<<"类资源的资源量";
			cout<<"申请不合理出错请重新选择"<<endl<<endl;
            flag='N';
			break;
	   
		 }
	     else
		 {
			 if(Request[j]>AVAILABLE[j])
			 {
			  cout<<"进程P"<<i<<"申请的资源数大于系统可用"<<j<<"类资源的资源量";
			  cout<<"申请不合理，出错！请重新选择"<<endl;
			   flag='N';
			   break;
			 }
		 
		 
		 }
	   }
	   if(flag=='Y'||flag=='y')
	   {   changedata(i);
	       if (checksec(i))
		   {
		     cout<<endl;
			 cout<<"该分配导致系统不安全，本次申请不成功，不予分配"<<endl;
			 cout<<endl;
			 restoredata(i);
		   }
           else
		   {
		      cout<<endl;
			 //  cout<<"经安全检查，系统安全，分配成功，资源分配如下";
			  showdata();
			  if(checkmax(i))
			  {
			   cout<<" 资源分配成功后，该进程最大需求量满足  "<<endl;
               cout<<" 该进程结束后 回收资源"<<endl;
			   cout<<" 资源回收后，各进程的资源需求和分配情况如下所示"<<endl;
			   showdata();
			  
			  }
		   
		   }

	   }
     cout<<endl;
	 cout<<"是否继续银行家算法演示，按Y或y键继续，按N键退出";
	 cin>>flag;
   }



}

1．银行家算法中的数据结构

为了实现银行家算法，在系统中必须设置这样四个数据结构，分别用来描述系统中可利用的资源、所有进程对资源的最大需求、系统中的资源分配，以及所有进程还需要多少资源的情况。

(1)可利用资源向量Available。这是一个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目，其初始值是系统中所配置的该类全部可用资源的数目，其数值随该类资源的分配和回收而动态地改变。如果Available[j]=K，则表示系统中现有R,类资源K个。

(2)最大需求矩阵 Max。这是一个nx m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。如果Max[i,j]=K，则表示进程i需要R类资源的最大数目为K。

(3)分配矩阵 Allocation。这也是一个nxm的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。如果 Allocation[i,j]=K，则表示进程i当前已分得R;类资源的数目为K。

(4）需求矩阵 Need。这也是一个nxm的矩阵，用以表示每一个进程尚需的各类资源数。如果 Need[i,j]=K，则表示进程i还需要Rj类资源K个方能完成其任务。

上述三个矩阵间存在下述关系:

Need[i,jil]= Max[i, j]- Allocation[i,j]

2.银行家算法

设Request ;是进程P的请求向量，如果 Request:[i]=K，表示进程P,需要K个R类型的资源。当P发出资源请求后，系统按下述步骤进行检查:

(1)如果 Request;j]≤Need[i,j]，便转向步骤(2);否则认为出错，因为它所需要的资源数已超过它所宣布的最大值。

(2)如果 Request;ji]≤Available[i]，便转向步骤(3):否则，表示尚无足够资源，Р ﹔须等待。

(3)系统试探着把资源分配给进程P，并修改下面数据结构中的数值:

Available[j] =Available[j]- Request [jl;

Allocation[i, j] = Allocation[i,j] + Request;l;Need[i, j] = Need[i,j]- Request l];

(4)系统执行安全性算法，检查此次资源分配后系统是否处于安全状态。若安全，才正式将资源分配给进程P，以完成本次分配;否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程P等待。

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)当进程P获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行:

Workj] = Work[j]+Allocation[i,j];Finish[i]=true;

go to step 2;

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

将测试数据输入

阿阿阿扶

关注

3
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
银行家算法实现（操作系统实验）

#include <string.h>#include<iostream.h>#define FALSE 0#define TRUE 1#define W 10#define R 20int M;int N;int ALL_RESOURCE[W];int AVAILABLE[R];int MAX[W][R];int ALLOCATION[W][R]; //分配矩阵int NEED[W][R]; //需求矩阵int Request[R];.
复制链接

扫一扫