【操作系统实验 / C++】模拟银行家算法(附代码)

1、题目要求

请参照课本上的银行家算法的实例,设计、实现银行家算法。
输入:某个进程请求的资源数量;
输出:已分配或者拒绝本次请求。
要求循环显示提示信息“请输入请求资源的数量和进程号:”。

2、数据结构设计

根据题目要求,以及银行家算法的特性,使用了多个全局数组用于存储进程和资源的情况。共5个进程,3个资源,如下图所示。

int Available[3];           //可用资源数组   
int Need[5][3] = {0};       //需要资源数组   
int Max[5][3];              //最大需求量数组   
int Allocation[5][3];       //当前分配资源数组   
int Request[5][3] = {0};    //请求的资源数  
int IsFinish[5] = {0};      //判断进程是否完成的数组   
int Array[5] = {0};         //安全队列数组   
int FinishNum = 0;          //完成算法的进程个数   
int n=0;                    //表示当前正在处理的进程序号   

同时,除了资源相关的数组外,还设置了几个信号量数组或值,用于存储每一个进程的完成情况、安全队列、完成的进程个数等。

3、程序主要思路和原理

主要思路:

  • 对于该题目,我完成了两种算法,一种是题目要求的循环请求资源,输入进程的序号以及请求资源数,达到所需资源数后完成进程,以及释放资源。另一种是产生一组随机数,并尝试能否通过这组随机数产生一个安全队列,若能够产生则输出该队列。
  • 提到的两种方法中,在请求资源的部分两者共用相同的函数,即判断输入的进程所需的资源数能否被当前可用的资源数满足,若能满足则分配该资源,完成进程后释放资源。同时,对银行家算法特性设置了一个安全检测函数,检测当前的资源分配是否会导致冲突,即其他的内存均没有足够的资源,若资源分配导致不安全则阻止此次分配。
  • 不同的地方在于,产生安全队列的算法中,我采用了一个随机数算法用来生成一个0-4的随机数,随后尝试当前可用资源能否满足该序号的进程运行,若能满足则先将资源分配给该进程,进程结束后再释放资源,同时修改进程相关的信号量,避免再次分配资源给该进程。若在规定次数(50次)内5个进程均完成,则输出记录的安全队列,否则停止循环并说明未找到安全序列。

原理:全局数组、变量,安全性检测,随机数算法

4、程序运行结果

首先运行程序,进行初始化。依次输入最大需求数目Max,已分配数目Allocation,以及当前资源的可用数目Available。随后打印出当前进程和资源的列表,可见需要的资源数目Need已经算出。

在这里插入图片描述

  • ①随机数算法产生安全队列: 随后出现操作列表,选择操作2,则开始通过一组随机数产生安全队列,并且依次输出结果,如下图所示。
    在这里插入图片描述
    在这里插入图片描述
    可见成功的产生了一组安全序列。

  • ②循环请求资源: 再次运行程序,初始化后选择操作1,首先对进程0请求一个A资源,输出结果如下图所示。
    在这里插入图片描述
    此时若再对进程1请求一个C资源,会造成系统死锁,资源不足以分配,此时安全性算法检测到了该错误,拒绝了此次资源分配。

在这里插入图片描述
此时再对进程0请求一个B资源,安全性算法没有产生问题。完成分配。
在这里插入图片描述
最后再对进程0请求一个C资源,进程0达到了最大需求,进程进行并完成,随后释放资源。可以看到进程0的已分配矩阵和需要资源都进行了清零,同时原先分配的资源全部进入剩余可用资源。

在这里插入图片描述

由上述结果可知,程序运行正常,且能够完成预先设定的两种运算,即循环请求资源和随机数算法产生安全队列,该实验完成。

5、详细代码

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
using namespace std;

int Available[3];			//可用资源数组 
int Need[5][3] = {0};		//需要资源数组 
int Max[5][3];				//最大需求量数组 
int Allocation[5][3];		//当前分配资源数组 
int Request[5][3] = {0};	//请求的资源数
int IsFinish[5] = {0};		//判断进程是否完成的数组 
int Array[5] = {0};			//安全队列数组 
int FinishNum = 0;			//完成算法的进程个数 
int n=0;					//表示当前正在处理的进程序号 

void Show()			//展示函数 
{
	cout<<endl;
	cout<<"----------------------------------------------------------------------------"<<endl;
	cout<<'\t'<<'\t'<<"最大需求矩阵"<<'\t'<<"已分配矩阵"<<'\t'<<"需要资源"<<'\t'<<"剩余可用资源"<<endl;
	cout<<'\t'<<'\t'<<"     Max    "<<'\t'<<"Allocation"<<'\t'<<"  Need  "<<'\t'<<"  Available "<<endl;
	cout<<"----------------------------------------------------------------------------"<<endl;
	cout<<"进程名称"<<"\tA   B   C "<<"\tA   B   C"<<"\tA   B   C"<<"\tA   B   C"<<endl;
	
	int i,j;
	for(i=0; i<5; i++)
	{
		cout<<"   P"<<i<<'\t'<<'\t';
		
		for(j=0; j<3; j++)
			cout<<Max[i][j]<<"   ";
		cout<<'\t';
		
		for(j=0; j<3; j++)
			cout<<Allocation[i][j]<<"   ";
		cout<<'\t';
		
		for(j=0; j<3; j++)
			cout<<Need[i][j]<<"   ";
		cout<<'\t';
		
		if(i == 0)
		{
			for(j=0; j<3; j++)
				cout<<Available[j]<<"   ";
		}
		cout<<endl;
	}
	cout<<"----------------------------------------------------------------------------"<<endl;
}


bool Check()		//对银行家算法的安全性检测 
{
	int i,j;
	int work[3] = {0};
	bool finish[3];
	
	for(i=0; i<3; i++)			//初始化 
		work[i] = Available[i];
	for(j=0; j<3; j++)
		finish[j] = false;
	
	int check = 0;
	bool flag;
	
	for(i=0; i<3; i++)
	{
		if(Need[n][i] <= work[i])
			check ++;
	}
	
	if(check == 3)
		flag = true;
	else
		flag = false;
	
	check = 0;
	
	for(i=0; i<3; i++)		//循环检测 
	{
		for(i=0; i<3; i++)
		{
			if(finish[i] == false && flag == true)
			{
				for(j=0; j<3; j++)
					work[j] = work[j] + Allocation[n][j];
				finish[i] = true;
				check ++;
			}
		}
	}
	
	if(check == 3)
		return true;
	else
		return false;
}


int Finish(int i)		//检测某一进程是否完成 
{
	int j;
	int check = 0;
	
	for(j=0; j<3; j++)
	{
		if(Need[i][j] == 0)
			check ++;
	}
	
	if(check == 3)
		IsFinish[i] = 1;
	return IsFinish[i];
}


void Process()			//处理请求的函数 
{
	int i,j,check1 = 0,check2 = 0;
	
	for(i=0; i<3; i++)
	{
		if(Request[n][i] <= Need[n][i])
		{
			if(Request[n][i] <= Available[i])
				check1 ++;
			else
			{
				cout<<"没有足够的资源分配给进程"<<n<<"请求的 ";
				for(j=0; j<3; j++)
				{
					cout<<Request[n][j]<<" ";
				}
				cout<<",请等待!"<<endl<<endl;
			}
		}
		
		else
		{
			cout<<"进程"<<n<<"请求的资源 ";
			for(j=0; j<3; j++)
				cout<<Request[n][j]<<" ";
			cout<<"超过了进程的需求数!"<<endl;
		}
	}
	
	if(check1 == 3)		//若请求的资源数目均小于可用 
	{
		cout<<endl<<"开始处理进程"<<n<<"的请求 ";
		for(i=0; i<3; i++)
			cout<<Request[n][i]<<" ";
		cout<<endl;
		
		for(j=0; j<3; j++)
		{
			Available[j] = Available[j] - Request[n][j];
			Allocation[n][j] = Allocation[n][j] + Request[n][j];
			Need[n][j] = Need[n][j] - Request[n][j];
		}
		
		if(Check() == true)
		{
			if(Finish(n) == 1)		//如果进程结束则释放资源 
			{
				cout<<endl<<"进程"<<n<<"已经结束,释放资源。"<<endl;
				
				for(i=0; i<3; i++)
				{
					Available[i] = Available[i] + Allocation[n][i];
					Allocation[n][i] = 0;
					Need[n][i] = 0;
				}
				
				Array[FinishNum] = n;
				FinishNum ++;
			}
			Show();
		}
		
		else
		{
			cout<<endl<<"进程"<<n<<"请求的资源 ";
			for(j=0; j<3; j++)
				cout<<Request[n][j]<<" ";
			cout<<"导致系统不安全!资源申请失败!返回。"<<endl;
			
			for(j=0; j<3; j++)		//回收资源 
			{
				Available[j] = Available[j] + Request[n][j];
				Allocation[n][j] = Allocation[n][j] - Request[n][j];
				Need[n][j] = Need[n][j] + Request[n][j];
			}
		}
	}
}


void Requester()		//请求队列,产生一个 0-4 的随机数,并尝试是否能生成安全队列 
{
	int i,j,check = 0;
	time_t t;
	srand((unsigned)time(&t)+rand());
	n = rand()%5;
	
	for(i=0; i<3; i++)
	{
		if(Need[n][i] <= Available[i])
			check ++;
	}
	
	for(j=0; j<3; j++)
	{
		if(check == 3)
		{
			Request[n][j] = Need[n][j];
		}
		else
		{
			srand((unsigned)time(&t)+rand());
			Request[n][j] = rand()%5;
		}
	}
	
	if(IsFinish[n] == 0)
		Process();
	else
		return; 
}


int main()
{
	int i,j;
	cout<<"银行家算法,共有5个进程,3种资源,首先分配资源。"<<endl;
	cout<<"请输入每个进程对于每个资源的最大需求数目(3*5):"<<endl;
	for(i=0; i<5; i++)
	{
		for(j=0; j<3; j++)
			cin>>Max[i][j];
	}
	
	cout<<"请输入每个进程的每个资源的已分配数目(3*5):"<<endl;
	for(i=0; i<5; i++)
	{
		for(j=0; j<3; j++)
		{
			cin>>Allocation[i][j];
			Need[i][j] = Max[i][j] - Allocation[i][j];
			
			if(Need[i][j] < 0)
				Need[i][j] = 0;
		}
	}
	
	cout<<"请输入每个资源的现有可用数目(3):";
	for(i=0; i<3; i++)
		cin>>Available[i];
	
	cout<<endl<<"初始化..."<<endl;
	Show();
	
	int check = 0;
	char choice;
	
	cout<<endl<<"-------------操作列表-------------"; 
	cout<<endl<<"请选择银行家算法的操作模式:";
	cout<<endl<<"1.手动请求资源,循环输入进程序号;";
	cout<<endl<<"2.根据所给的资源自主算出安全队列。";
	cout<<endl<<"----------------------------------";
	cout<<endl<<"**请输入选择的操作:";
	cin>>choice;
	
	switch(choice)
	{
		case '1':
			do
			{
				cout<<endl<<"请输入进程号(0-4):";
				cin>>n;
				
				cout<<endl<<"请输入请求的资源(3):";
				for(i=0; i<3; i++)
					cin>>Request[n][i];
					
				Process(); 
			}while(FinishNum < 5);
			break;
		
		case '2':
			do
			{
				Requester();
				check ++;
			}while(check != 50);
			
			if(FinishNum == 5)
			{
				cout<<endl<<"发现一组安全序列:";
				for(i=0; i<4; i++)
					cout<<Array[i]<<"-->";
				cout<<Array[4]<<endl<<endl;
			}
			else
				cout<<endl<<"在规定次数内未发现安全序列。"<<endl<<endl;
				break;
				
		default:
			cout<<endl<<"输入错误!程序将关闭,请重新启动。"<<endl<<endl;
			break;
	}
	
	system("pause");
	return 0;
}
实验目的】 1. 理解死锁的概念; 2. 用高级语言编写和调试一个银行家算法程序,以加深对死锁的理解。 【实验准备】 1. 产生死锁的原因  竞争资源引起的死锁  进程推进顺序不当引起死锁 2.产生死锁的必要条件  互斥条件  请求和保持条件  不剥夺条件  环路等待条件 3.处理死锁的基本方法  预防死锁  避免死锁  检测死锁  解除死锁 【实验内容】 1. 实验原理 银行家算法是从当前状态出发,逐个按安全序列检查各客户中谁能完成其工作,然后假定其完成工作且归还全部贷款,再进而检查下一个能完成工作的客户。如果所有客户都能完成工作,则找到一个安全序列,银行家才是安全的。与预防死锁的几种方法相比较,限制条件少,资源利用程度提高了。缺点:该算法要求客户数保持固定不变,这在多道程序系统中是难以做到的;该算法保证所有客户在有限的时间内得到满足,但实时客户要求快速响应,所以要考虑这个因素;由于要寻找一个安全序列,实际上增加了系统的开销.Banker algorithm 最重要的一点是:保证操作系统的安全状态!这也是操作系统判断是否分配给一个进程资源的标准!那什么是安全状态?举个小例子,进程P 需要申请8个资源(假设都是一样的),已经申请了5个资源,还差3个资源。若这个时候操作系统还剩下2个资源。很显然,这个时候操作系统无论如何都不能再分配资源给进程P了,因为即使全部给了他也不够,还很可能会造成死锁。若这个时候操作系统还有3个资源,无论P这一次申请几个资源,操作系统都可以满足他,因为操作系统可以保证P不死锁,只要他不把剩余的资源分配给别人,进程P就一定能顺利完成任务。 2.实验题目 设计五个进程{P0,P1,P2,P3,P4}共享三类资源{A,B,C}的系统,{A,B,C}的资源数量分别为10,5,7。进程可动态地申请资源和释放资源,系统按各进程的申请动态地分配资源。要求程序具有显示和打印各进程的某一时刻的资源分配表和安全序列;显示和打印各进程依次要求申请的资源号以及为某进程分配资源后的有关资源数据。 3.算法描述 我们引入了两个向量:Resourse(资源总量)、Available(剩余资源量) 以及两个矩阵:Claim(每个进程的最大需求量)、Allocation(已为每个进程分配的数量)。它们共同构成了任一时刻系统对资源的分配状态。 向量模型: R1 R2 R3 矩阵模型: R1 R2 P1 P2 P3 这里,我们设置另外一个矩阵:各个进程尚需资源量(Need),可以看出 Need = Claim – Allocation(每个进程的最大需求量-剩余资源量) 因此,我们可以这样描述银行家算法: 设Request[i]是进程Pi的请求向量。如果Request[i , j]=k,表示Pi需k个Rj类资源。当Pi发出资源请求后,系统按下述步骤进行检查: (1) if (Request[i]<=Need[i]) goto (2); else error(“over request”); (2) if (Request[i]<=Available[i]) goto (3); else wait(); (3) 系统试探性把要求资源分给Pi(类似回溯算法)。并根据分配修改下面数据结构中的值。 剩余资源量:Available[i] = Available[i] – Request[i] ; 已为每个进程分配的数量: Allocation[i] = Allocation[i] + Request[i]; 各个进程尚需资源量:Need[i] = Need[i]-Request[i]; (4) 系统执行安全性检查,检查此次资源分配后,系统是否处于安全状态。若安全,才正式将资源分配给进程以完成此次分配;若不安全,试探方案作废,恢复原资源分配表,让进程Pi等待。 系统所执行的安全性检查算法可描述如下: 设置两个向量:Free、Finish 工作向量Free是一个横向量,表示系统可提供给进程继续运行所需要的各类资源数目,它含有的元素个数等于资源数。执行安全算法开始时,Free = Available .标记向量Finish是一个纵向量,表示进程在此次检查中中是否被满足,使之运行完成,开始时对当前未满足的进程做Finish[i] = false;当有足够资源分配给进程(Need[i]<=Free)时,Finish[i]=true,Pi完成,并释放资源。 (1)从进程集中找一个能满足下述条件的进程Pi ① Finish[i] == false(未定) ② Need[i] D->B->A A 1 6 B 1 5 C 2 4 D 4 7 Available = (2) ; Resourse = (10) ; 测试结果如下 process number:5 resource number:4 resource series:6 3 4 2 assined matrix:p0:3 0 1 1 p1:0 1 0 0 p2:1 1 1 0 p3:1 1 0 1 p4:0 0 0 0 needed matrix: p0:1 1 0 0 p1:0 1 1 2 p2:3 1 0 0 p3:0 0 1 0 p4:2 1 1 0 p3-->p4-->p0-->p2-->p1 p3-->p4-->p0-->p1-->p2 p3-->p0-->p4-->p2-->p1 p3-->p0-->p4-->p1-->p2 p3-->p0-->p2-->p4-->p1 p3-->p0-->p2-->p1-->p4 p3-->p0-->p1-->p4-->p2 p3-->p0-->p1-->p2-->p4 it is safe,and it has 8 solutions
评论 7
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值