操作系统银行家算法模拟实现(C语言版)

目录

一、实验目的        

二、实验内容

三、实验要点说明

银行家算法实例

程序结构

四、实验代码

五、实验运行结果


一、实验目的        

       通过编写一个模拟动态资源分配的银行家算法程序,进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念,并掌握避免死锁的具体实施方法。

二、实验内容

  • (1)模拟一个银行家算法: 设置数据结构 设计安全性算法
  • (2) 初始化时让系统拥有一定的资源
  • (3) 用键盘输入的方式申请资源
  • (4)如果预分配后,系统处于安全状态,则修改系统的资源分配情况
  • (5)如果预分配后,系统处于不安全状态,则提示不能满足请求

三、实验要点说明

数据结构

  •  可利用资源向量   int  Available[m]   m为资源种类
  • 最大需求矩阵        int  Max[n][m]     n为进程的数量
  • 分配矩阵               int  Allocation[n][m]
  • 还需资源矩阵        int  need[i][j]=Max[i][j]- Allocation[i][j]
  • 申请资源数量        int  Request [m]  
  • 工作向量               int  Work[m]    int  Finish[n]

银行家算法bank()函数

Requesti:进程Pi的请求向量。   0<=j<=m-1

  • (1) 若 Requesti[j] ≤ Need[i,j],转向(2),否则出错。
  • (2) 若 Requesti[j] ≤ Available[j],转向(3),否则等待。
  • (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等待。

安全性算法safe()函数

  • (1) 初始化:设置两个向量Work(1×m)和Finish(1×n)
  •       Work – 系统可提供给进程继续运行所需各类资源数,初态赋值Available
  •       Finish – 系统是否有足够资源分配给进程,初值false.
  • (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 (2).
  • (4) 若所有进程Finish[i] = true,表示系统处于安全状态,否则处于不安全状态。

先对用户提出的请求进行合法性检查,即检查请求的是否不大于需要的,是否不大于可利用的。 若请求合法,则进行试分配。最后对试分配后的状态调用安全性检查算法进行安全性检查。 若安全,则分配,否则,不分配,恢复原来状态,拒绝申请。

银行家算法实例

假定系统中有五个进程{P0、P1、P2、P3、P4}和三种类型资源{A、B、C},每一种资源的数量分别为10、5、7。各进程的最大需求、T0时刻资源分配情况如下所示。

试问:      

  • ①T0时刻是否安全?      
  • ② T0之后的T1时刻P1请求资源Request1(1,0,2)是否允许?      
  • ③ T1之后的T2时刻P4请求资源Request4(3,3,0)是否允许?      
  • ④ T2之后的T3时刻P0请求资源Request0(0,2,0)是否允许?

① T0时刻是否安全? 工作向量Work.它表示系统可提供给进程继续运行所需要的各类资源的数目

(1) T0时刻安全性分析

存在安全序列{P1, P3, P4, P0, P2},系统安全。

(2) T0之后的T1时刻P1请求资源Request1(1,0,2)可否允许?

  • ①Request1(1,0,2) ≤ Need1(1,2,2),P1请求在最大需求范围内
  • ②Request1(1,0,2) ≤ Available1(3,3,2),可用资源可满足P1请求需要
  • ③假定可为P1分配,修改Available,Allocation1,Need1向量
  •     Available(2,3,0) = Available(3,3,2)-Request1(1,0,2);
  •     Need1(0,2,0) = Need1(1,2,2)-Request1(1,0,2);
  •     Allocation1(3,0,2) =Allocation1(2,0,0)+Request1(1,0,2);
  • ④利用安全性算法检查试探将资源分配后状态的安全性

存在安全序列{P1, P3, P4, P0, P2},所以试探将资源分配给进程P1后的状态是安全的,可将资源分配给进程P1。

③ T1之后的T2时刻P4请求资源Request4(3,3,0)是否允许?

  • Request4(3,3,0)≤Need4(4,3,1),P4请求在最大需求范围内。
  • Request4(3,3,0)≤Available(2,3,0)不成立,即可用资源暂不能满足P4请求资源需要,P4阻塞等待。

P4请求资源Request4(3,3,0)不允许。

④ T2之后的T3时刻P0请求资源Request0(0,2,0)是否允许?

  • Request0(0,2,0)≤Need0(7,4,3);
  • Request0(0,2,0)≤Available(2,3,0);

系统暂时先假定可为P0分配资源,并修改有关数据,如下图所示:

进行安全性检查:可用资源Available(2,1,0)已不能满足任何进程的需要,故系统进入不安全状态,此时系统不分配资源。

程序结构

程序共有以下五个部分:

  • (1).初始化init():输入进程数量、资源种类、资源可利用量、进程资源已分配量、进程最大需求量
  • (2).当前安全性检查safe():用于判断当前状态安全
  • (3).银行家算法bank():进行银行家算法模拟实现的模块
  • (4).显示当前状态show():显示当前资源分配详细情况
  • (5).主程序main():逐个调用初始化、显示状态、安全性检查、银行家算法函数,使程序有序的进行

四、实验代码

#include<stdio.h>
#include<stdlib.h>

#define False 0
#define True 1

/********主要数据结构********/
char NAME[100]={0};//资源的名称
int Max[100][100]={0};//最大需求矩阵
int Allocation[100][100]={0};//系统已分配矩阵
int Need[100][100]={0};//还需要资源矩阵
int Available[100]={0};//可用资源矩阵
int Request[100]={0};//请求资源向量	
int Work[100]={0};//存放系统可提供资源量 
int Finish[100]={0}; //标记系统是否有足够的资源分配给各个进程 
int Security[100]={0};//存放安全序列

int M=100;//进程的最大数
int N=100;//资源的最大数

/********初始化数据:输入进程数量、资源种类、各种资源可利用数量、
各进程对资源最大需求量、各进程的资源已分配数量等。********/
void init()
{
	/* m为进程个数,即矩阵行数,n为资源种类,即矩阵列数。*/
    int i,j,m,n;
	int number,flag;
	char name;//输入资源名称
	int temp[100]={0};//统计已经分配的资源
	//输入系统资源数目及各资源初试个数 
	printf("系统可用资源种类为:");
	scanf("%d",&n);
	N=n;
	for(i=0;i<n;i++)
	{
		printf("资源%d的名称:",i);
		fflush(stdin);  //清空输入流缓冲区的字符,注意必须引入#include<stdlib.h>头文件
		scanf("%c",&name);
		NAME[i]=name;
		printf("资源%c的初始个数为:",name);	
		scanf("%d",&number);
		Available[i]=number;
	}
	
	//输入进程数及各进程的最大需求矩阵 
	printf("\n请输入进程的数量:");	
	scanf("%d",&m);
	M=m;
	printf("请输入各进程的最大需求矩阵的值[Max]:\n");
	do{
		flag = False;
		for(i=0;i<M;i++)
			for(j=0;j<N;j++)
			{
				scanf("%d",&Max[i][j]);
				if(Max[i][j]>Available[j])
					flag = True;				
			}
		if(flag)
			printf("资源最大需求量大于系统中资源最大量,请重新输入!\n");								
	} while(flag);
	
			
	//输入各进程已经分配的资源量,并求得还需要的资源量 
	do{
		flag=False;
		printf("请输入各进程已经分配的资源量[Allocation]:\n");
		for(i=0;i<M;i++)
		{
			for(j=0;j<N;j++)
		  	{
				scanf("%d",&Allocation[i][j]);
				if(Allocation[i][j]>Max[i][j])  
					flag=True;				
				Need[i][j]=Max[i][j]-Allocation[i][j];
				temp[j]+=Allocation[i][j];//统计已经分配给进程的资源数目
		  	}
		}
		if(flag)
			printf("分配的资源大于最大量,请重新输入!\n");		
	}while(flag);
	
	//求得系统中可利用的资源量 
	for(j=0;j<N;j++)
		Available[j]=Available[j]-temp[j];
}

/********显示资源分配矩阵********/
void showdata()
{
	int i,j;
	printf("*************************************************************\n");
	printf("系统目前可用的资源[Available]:\n");
	for(i=0;i<N;i++)
        printf("%c  ",NAME[i]);
	printf("\n");
	for(j=0;j<N;j++)
        printf("%d  ",Available[j]);
	printf("\n");
	printf("系统当前的资源分配情况如下:\n");
	printf("            Max   	 Allocation    Need\n");
	printf("进程名     ");
	//输出与进程名同行的资源名,Max、Allocation、Need下分别对应 
	for(j=0;j<3;j++){
		for(i=0;i<N;i++)
			printf("%c  ",NAME[i]);
		printf("     ");
	}
	printf("\n");
	//输出每个进程的Max、Allocation、Need 
	for(i=0;i<M;i++){
		printf(" P%d        ",i);
	    for(j=0;j<N;j++)
			printf("%d  ",Max[i][j]);
		printf("     "); 
		for(j=0;j<N;j++)
			printf("%d  ",Allocation[i][j]);
		printf("     "); 
		for(j=0;j<N;j++)
			printf("%d  ",Need[i][j]);
		printf("\n");
	}
}

/********尝试分配资源********/
int test(int i) //试探性的将资源分配给第i个进程 
{ 
	for(int j=0;j<N;j++)
	{
		Available[j]=Available[j]-Request[j];
		Allocation[i][j]=Allocation[i][j]+Request[j];
		Need[i][j]=Need[i][j]-Request[j];
	}
	return True;
}

/********试探性分配资源作废********/
int Retest(int i) //与test操作相反 
{ 
	for(int j=0; j<N; j++)
	{
		Available[j] = Available[j] + Request[j];
		Allocation[i][j] = Allocation[i][j] - Request[j];
		Need[i][j] = Need[i][j] + Request[j];
	}
	return True;
}

/********安全性算法********/
int safe()
{
	int i,j,k=0,m,apply;
	//初始化work 
	for(j=0;j<N;j++)
        Work[j] = Available[j];
    //初始化Finish 
    for(i=0;i<M;i++) 
    	Finish[i] = False;
	//求安全序列 
	for(i=0;i<M;i++){ 
		apply=0;
		for(j=0;j<N;j++){
			if(Finish[i]==False && Need[i][j]<=Work[j])
			{   
				apply++;
				//直到每类资源尚需数都小于系统可利用资源数才可分配
				if(apply==N)
				{  
					for(m=0;m<N;m++)
				        Work[m]=Work[m]+Allocation[i][m];//更改当前可分配资源
					Finish[i]=True;
					Security[k++]=i;
					i=-1; //保证每次查询均从第一个进程开始		
				}
			}
		}
	}
	
	for(i=0;i<M;i++){
		if(Finish[i]==False){
			printf("系统不安全\n");//不成功系统不安全
			return False;
		}
	}
    printf("系统是安全的!\n");//如果安全,输出成功
    printf("存在一个安全序列:");
	for(i=0;i<M;i++){//输出运行进程数组
		printf("P%d",Security[i]);
		if(i<M-1) 
			printf("->");
	}
	printf("\n");
	return True;
}

/********利用银行家算法对申请资源进行试分********/
void bank()
{
	int flag = True;//标志变量,判断能否进入银行家算法的下一步 
	int i,j;

	printf("请输入请求分配资源的进程号(0-%d):",M-1); 
    scanf("%d",&i);//输入须申请资源的进程号
    
	printf("请输入进程P%d要申请的资源个数:\n",i);
	for(j=0;j<N;j++)
	{
		printf("%c:",NAME[j]);
		scanf("%d",&Request[j]);//输入需要申请的资源
	}
	
	//判断银行家算法的前两条件是否成立 
    for (j=0;j<N;j++)
	{
		if(Request[j]>Need[i][j])//判断申请是否大于需求,若大于则出错
		{ 
			printf("进程P%d申请的资源大于它需要的资源",i);
			printf("分配不合理,不予分配!\n");
			flag = False;
			break;
		}
		else 
		{
            if(Request[j]>Available[j])//判断申请是否大于当前可分配资源,若大于则出错
			{                         
				printf("进程%d申请的资源大于系统现在可利用的资源",i);
				printf("\n");
				printf("系统尚无足够资源,不予分配!\n");
				flag = False;
				break;
			}
		}
    }
    //前两个条件成立,试分配资源,寻找安全序列 
    if(flag) {
		test(i); //根据进程需求量,试分配资源 
		showdata(); //根据进程需求量,显示试分配后的资源量 
		if(!safe()) //寻找安全序列
		{
			Retest(i);
			showdata();
		}
    }
}


int main()//主函数
{	
	char choice;
	printf("\t---------------------------------------------------\n");
	printf("\t||                                               ||\n");
	printf("\t||               银行家算法的实现                ||\n");
	printf("\t||                                               ||\n");
	printf("\t||                                               ||\n");
	printf("\t||                     在此输入个人姓名:******  ||\n");
	printf("\t||                                               ||\n");
	printf("\t---------------------------------------------------\n");
	init();//初始化数据
    showdata();//显示各种资源
    //用银行家算法判定系统当前时刻是否安全,不安全就不再继续分配资源 
	if(!safe()) exit(0);
	
	do{
		printf("*************************************************************\n");
		printf("\n");
		printf("\n");
		printf("\t-------------------银行家算法演示------------------\n");
		printf("                     R(r):请求分配   \n");	
		printf("                     E(e):退出       \n");
		printf("\t---------------------------------------------------\n");
		printf("请选择:");
		fflush(stdin);  //清空输入流缓冲区的字符,注意必须引入#include<stdlib.h>头文件
		scanf("%c",&choice);
		switch(choice)
		{
			case 'r':
			case 'R':
				bank();break;			
			case 'e':
			case 'E':
				exit(0);
			default: printf("请正确选择!\n");break;
		}
	} while(choice);
}


五、实验运行结果

 

 

 

 

 

展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 程序猿惹谁了 设计师: 上身试试
应支付0元
点击重新获取
扫码支付

支付成功即可阅读