操作系统之银行家算法实现代码

最新推荐文章于 2023-09-23 17:47:35 发布
最新推荐文章于 2023-09-23 17:47:35 发布
阅读量3.6w 收藏 355
点赞数 59
分类专栏： C/C++ 文章标签： 银行家算法实现代码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/stf1065716904/article/details/80932830
版权

完成与：2013.12.11左右

1. 算法思想

银行家算法是为了避免死锁的算法，是Dijkstra的银行家算法。由于该算法用于实现银行系统现金贷款的发放而得名的。为实现银行家算法，系统中必须设置若干数据结构。

1） 银行家算法的数据结构

a) 可利用资源向量available

b) 最大需求矩阵

c) 分配矩阵

d) 需求矩阵

2） 银行家算法

设Requesti 是进程Pi的请求量，如果Requesti[j]=k,表示进程Pi需要K个Rj类型的资源。当Pi发出资源请求后，系统按下述步骤进行检查。

a) 如果Requesti[j] <=Need[I,j],便转向步骤（b）；否则认为出错，因为他所需要的资源数已经超过它所宣布的最大值。

b) 如果Requesi[j] <=Available[j],便转向步骤（c）；否则，表示尚无足够的资源，Pi须等待。

c) 系统试探着把资源分配给进程Pi，并修改下面的数据结构中的数值：

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];

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

3） 安全算法

系统所执行的安全算法可描述如下：

（1） 设置两个向量：

 ① 工作向量Work，它表示系统可提供给进程继续运行所需的各类资源数目，它含有m个元素，在执行安全算法开始时，Work :=Available。

② Finish，他表示系统是否有足够的资源分配给进程，使之运行完成。开始时先做Finish := 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 step2;

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

 

 

 

2. 程序代码

#include <stdio.h>
#include <stdlib.h>
#include "head.h"
#include <string.h>
#include <windows.h>

#define PRONUM 80	//进程的最大数目
#define RESNUM 80	//资源的最大数目
#define RESLEN 80	//资源名的最大数目
typedef struct Max_Allocation//进程已分配资源量
{
	char			proName[PRONUM];//进程名
	int				iMax[RESNUM];//最大需求量
	int				iAllocation[RESNUM];//进程已分配资源量
	int				need[RESNUM];//需求量
}Max_Allocation; 
struct course
{
	Max_Allocation	res;//资源需求与分配信息
	int				finish;//是否访问的标志。（0未访问，1已经访问）
};
char	 	 resName[RESNUM][RESLEN];//资源名
int		 work[RESNUM];//可用资源数
int		 request[RESNUM]={0};//请求资源
char	 	 safe_Array[RESNUM][RESLEN];//资源名
int	     available[RESNUM];//可用资源
struct course progress[80]; 
void health_Examination(int proNum, int resNum)
{return; }

///
//此处仅供调试方便
//
void test(){
progress[0].res.iMax[0]=7;
	progress[0].res.iMax[1]=5;
	progress[0].res.iMax[2]=3;
	progress[0].res.iAllocation[0]=0;
	progress[0].res.iAllocation[1]=1;
	progress[0].res.iAllocation[2]=0;

	progress[1].res.iMax[0]=3;
	progress[1].res.iMax[1]=2;
	progress[1].res.iMax[2]=2;
	progress[1].res.iAllocation[0]=2;
	progress[1].res.iAllocation[1]=0;
	progress[1].res.iAllocation[2]=0;

	progress[2].res.iMax[0]=9;
	progress[2].res.iMax[1]=0;
	progress[2].res.iMax[2]=2;
	progress[2].res.iAllocation[0]=3;
	progress[2].res.iAllocation[1]=0;
	progress[2].res.iAllocation[2]=2;

	progress[3].res.iMax[0]=2;
	progress[3].res.iMax[1]=2;
	progress[3].res.iMax[2]=2;
	progress[3].res.iAllocation[0]=2;
	progress[3].res.iAllocation[1]=1;
	progress[3].res.iAllocation[2]=1;

	progress[4].res.iMax[0]=4;
	progress[4].res.iMax[1]=3;
	progress[4].res.iMax[2]=3;
	progress[4].res.iAllocation[0]=0;
	progress[4].res.iAllocation[1]=0;
	progress[4].res.iAllocation[2]=2;

	strcpy(progress[0].res.proName, "P0");
	strcpy(progress[1].res.proName, "P1");
	strcpy(progress[2].res.proName, "P2");
	strcpy(progress[3].res.proName, "P3");
	strcpy(progress[4].res.proName, "P4");

	strcpy(resName[0], "A");
	strcpy(resName[1], "B");
	strcpy(resName[2], "C");
}

void init_Flag(int proNum, int resNum) {
	int i=0;
	for(i=0; i<proNum; i++){
		progress[i].finish=0;//访问标志初始化
	}
	return;
}
void init_Resource(int proNum, int resNum)//初始化资源
{int i=0, j=0;
	for(i=0; i<proNum; i++){
		for(j=0; j<resNum; j++){
			progress[i].res.iMax[j]=0;//最大需求量，初始化为0
			progress[i].res.iAllocation[j]=0;//进程已分配资源量，初始化为0
		}
	}
	return;
}
//初始化需求量
void init_Need(int proNum, int resNum)
{int i=0, j=0;
	for(i=0 ; i<proNum; i++){
		for(j=0 ; j<resNum; j++){
			progress[i].res.need[j]=0;
		}
	}
	return;
}
//初始化可用资源
void init_Available(int resNum) {
int i=0;
	for(i=0; i<resNum; i++){
		available[i]=0;
	}
	return;
}

//输入进程名，资源名，以及进程信息等
void input_info(int proNum, int resNum) {
	int i=0, j=0;
	for(i=0; i<proNum; i++){
		printf("请输入第%d个进程名<共%d>: ", i+1, proNum);
		scanf("%s", progress[i].res.proName);
		for(j=0; j<resNum; j++){
			if(i==0) {
				printf("    请输入第%d个资源类型名<共%d>: ", j+1, resNum);
				scanf("%s", resName[j]);
			}
			printf("        请输入%s类资源的最大需求量: ", resName[j]);
			scanf("%d", &progress[i].res.iMax[j]);
			printf("        请输入%s类资源的当前已分配量: ", resName[j]);
			scanf("%d", &progress[i].res.iAllocation[j]);
			printf(" \n");
		}
		printf(" \n");
	}
	return;
}

//给need赋值
void voluation_Need(int proNum, int resNum) {
	int i=0,j=0;
	for(i=0; i<proNum; i++){
		for(j=0; j<resNum; j++){
			progress[i].res.need[j]=progress[i].res.iMax[j] - progress[i].res.iAllocation[j];
		}
	}
	return;
}
//对可用资源的输入
void input_Available( int resNum) {
	int i=0;
	for(i=0; i<resNum; i++){
		printf("请输入%s类资源的可用数(按回车结束一类资源的输入): ", resName[i]);
		scanf("%d", &available[i]);
		/*
		if( available[i] == 'q' || available[i] == 'Q')//退出检测
		{
			printf("\n\n程序结束。\n");
			exit(0);
		}*/
	}
	return;
}
//初始化work
void init_Work( int resNum) {
	int i=0;
	for(i=0; i<resNum; i++){
		work[i]=*(available+i);
	}
	return;
}
//
//
//以下为整个程序的核心代码
//
///
//此处完成合法性的检查，判断系统是否安全
bool check_safety(int proNum, int resNum) {
	int i=0, j=0, Need=0, countPro=0, countFor=0, countLastPro=0, countFinish=0;//countFor统计循环的次数,countFinish统计已访问的次数
	int num=0;
	while(countPro < proNum ) {
		for(i=0; i<proNum; i++){
			if ( progress[i].finish != 1)//判断该进程是否已经被访问
			{
				for(j=0; j<resNum; j++){
					Need=progress[i].res.iMax[j] - progress[i].res.iAllocation[j]; 
					if( Need <= work[j] ) {continue; }
					else{break; }
				}
				if(j == resNum) {
					for(j=0; j<resNum; j++){
						work[j]=work[j] + progress[i].res.iAllocation[j];//资源拥有量
					}
					strcpy(safe_Array[num++], progress[i].res.proName);
					progress[i].finish=1;//把已访问的进程置1
					countPro++;//统计访问进程的个数
				}
			}
		}
		//以下两个判断都能够满足安全性的检查
		//判断1，效率高
		if(countLastPro == countPro)
		{//判断上一次循环统计的进程个数是否等于本次循环的进程个数，
			//若相等则说明可用资源不能满足当前进程的运行
			return false;
		}
		else{//若相等把这次的进程个数赋给上一次统计的个数
			countLastPro = countPro; }

		//判断2，效率低
		countFor++;//统计循环的次数，若循环次数大于当前进程的个数，则说明可用资源不能满足当前进程的运行
		if(countFor > proNum)//此处proNum加1，是为了防止与countPro相悖
		{return false; }
	}
	return true;
}
//输入请求进程请求名
int input_Request_Name(int proNum) {
	int position=0;
	char reqProName[PRONUM];
	bool flag=true;
	int i=0;
	printf("\n***********************************\n");
	while(flag) {
		printf("按“q”、“Q”结束程序。\n");
		printf("请输入资源请求的进程名：");
		scanf("%s", reqProName);
		if( strcmp(reqProName, "q") ==0 || strcmp(reqProName, "Q") ==0)//退出检测{
			printf("\n\n程序结束。\n");
			exit(0);
		}
		for(i=0; i<proNum; i++){
			if( strcmp(progress[i].res.proName, reqProName)==0 ) {
				position=i;
				flag=false;
				break;
			}
		}
		if( proNum == i)
		{printf("\n您输入的进程不存在。\n");}
	}
	return position;
}
//输入各类资源请求数
bool input_Res_Num(int proNum, int resNum, int *available, int position) {
	bool flag=false;
	int need=0;
	int i=0, iflag=-1;
	//char over; 
	printf("\n*************************************\n");
	printf("请输入资源请求量共%d种。\n", resNum);
	for(i=0; i<resNum; i++){
		printf("请输入第%s类资源请求: ", resName[i]);
		scanf("%d", &request[i]);
		/*if( request[i] == 89)//退出检测
		{
			printf("\n\n程序结束。\n");
			exit(0);
			break;
		}*/
	}
	//此处判断request<=Need 并且 request<=Available
	for(i=0; i<resNum; i++){
		need=progress[position].res.iMax[i] - progress[position].res.iAllocation[i];
		if (request[i] > need  ) {
			printf("资源请求量大于需求资源量，资源不分配\n");
			print_Info(proNum, resNum);//输出信息
			return false;
		}
		if ( request[i] > available[i] ) {
			printf("资源请求量大于可用资源量，资源不分配\n");
			print_Info(proNum, resNum);//输出信息
			return false;
		}
	}
	print_Info(proNum, resNum);//输出信息
	return true; 
}
//请求资源
void request_Resource(int proNum, int resNum, int *available) {
	bool flag=false, allFlag=true;
	int position=0, need=0;
	int i=0; 
	while(!flag) {
		position = input_Request_Name(proNum);//输入资源请求名
		flag = input_Res_Num(proNum, resNum, available, position);
	}
	init_Flag(proNum, resNum);
	init_Work(resNum);//初始化可用资源
	for(i=0; i<resNum; i++){
		progress[position].res.iAllocation[i] += request[i];
		work[i] -= request[i];
	}
	if( check_safety(proNum, resNum) ) {
		for(i=0; i<resNum; i++)//need值改变
		{progress[position].res.need[i] -= request[i]; }
		for(i=0; i<resNum; i++)//available值改变
		{available[i] -= request[i]; }
		printf("安全序列是：\n");
		printf("%s", safe_Array[0]);
		for(i=1; i<proNum; i++)
		{printf("->%s", safe_Array[i]); }
		putchar('\n'); 
		printf("\n此状态安全。\n");
	}
	else{
		printf("\n此状态不安全，资源不分配。\n");
		for(i=0; i<resNum; i++)
		{progress[position].res.iAllocation[i] -= request[i]; }
	}
	return;
}
//格式输出
void print_Info(int proNum, int resNum) {
	int i=0, j=0;
	printf("\n**************************************************************************************************\n");
	printf("********************                操作系统之银行家算法              ****************************\n");
	printf("**************************************************************************************************\n");
	printf("资源情况       Max\t     \t    Allocation\t      \t      Need\t      \t    Available\n");
	printf("进程");
	for(i=0; i<resNum; i++)
	{printf("\t%s", resName[i]); }
	for(i=0; i<resNum; i++)
	{printf("\t%s", resName[i]); }
	for(i=0; i<resNum; i++)
	{printf("\t%s", resName[i]); }
	for(i=0; i<resNum; i++)
	{printf("\t%s", resName[i]); }
	printf("\n\n");
	for(i=0; i<proNum; i++)
	{printf("%s", progress[i].res.proName); 
		for(j=0; j<resNum; j++)
		{printf("\t%d", progress[i].res.iMax[j]); }
		for(j=0; j<resNum; j++)
		{printf("\t%d", progress[i].res.iAllocation[j]); }
		for(j=0; j<resNum; j++)
		{printf("\t%d", progress[i].res.need[j]); }
		for(j=0; j<resNum && i==0; j++)
		{printf("\t%d", available[j]); }
		printf(" \n");
	}
	printf(" \n**************************************************************************************************\n");
	return;
}
//初始化所有需初始化
void init_All(int proNum, int resNum)
	init_Flag(proNum, resNum);//初始化相应的信息
	init_Resource(proNum, resNum);//初始化资源
	init_Need(proNum, resNum);//need初始化
	init_Available(resNum);//初始化可用资源
	test();
	//input_info(proNum, resNum);//输入相应信息
	voluation_Need(proNum, resNum);//给need赋值
	print_Info(proNum, resNum);//输出相应信息
	input_Available(resNum);//可用资源
	init_Work(resNum);//初始化可用资源
}
int main(int argc,char* argv[])
{
	int proNum=5, resNum=3;
	char ch=' ';
	bool is_safe=false;
	int i=0;
	system("title 操作系统之银行家算法  作者：宋腾飞");
	system("mode con cols=100 lines=30 ");//
	while(!is_safe) {
		//printf("请输入进程数及资源数：");
		//scanf("%d%c%d", &proNum, &ch, &resNum); 
		//health_Examination(proNum); 
		init_All(proNum, resNum); 
		if( check_safety(proNum, resNum) )
		{printf("\n此状态安全。\n");
			printf("安全序列是：\n");
			printf("%s", safe_Array[0]);
			for(i=1; i<proNum; i++)
			{printf("->%s", safe_Array[i]); }
			putchar('\n'); 
			is_safe=true; 
			print_Info(proNum, resNum);
		}
		else{
			printf("\n此状态不安全。等待5秒钟后请重新输......\n");
			is_safe=false;
			Sleep(5000);
			//system("cls");
		}
	}
	printf("请等待5秒......\n");
	Sleep(5000); 
	do
	{//system("cls");
		request_Resource(proNum, resNum, available); 
	}while(1); 
	//print_Info(proNum, resNum);//输出相应信息
	return 0;
}

3. 运行结果



易大飞
关注
  • 59
    点赞
  • 踩
  • 355
    收藏
    觉得还不错? 一键收藏
  • 21
    评论
专栏目录
银行家算法+安全性检查 【 死锁 】
weixin_74118029的博客
05-10 1141
printf("进程P%d Request_%c=%d > Available_%c=%d \n",i,'A'+j,Request[j],'A'+j,banker.Available[j]);综上所述，银行家算法的具体思想是通过动态地分析系统中各进程的资源需求，预测资源分配后系统是否会处于安全状态，以此来避免系统陷入死锁的危险状态，保证系统的稳定性和可靠性。// 输出请求向量中的资源数量。(2) 如果 Requesti[j]≤Available[j]，便转向步骤(3):否则，表示尚无足够资源，P须等待。
银行家算法 c语言
mdjsmg的博客
04-16 3027
操作系统学习之银行家算法，c语言代码实现
银行家算法——C语言实现
最新发布
mili_j的博客
09-23 2068
银行家算法——C语言实现
银行家算法及其c++代码实现
weixin_39660224的博客
08-05 2574
最近小编在学习自考操作系统的过程中，了解到了一种可以避免进程死锁的算法-----银行家算法 如果您已经知道什么是银行家算法，只想看代码，直接到 源码部分 什么是银行家算法 银行家算法是操作系统中避免死锁的一种算法 什么是死锁 和我们线程死锁类似，不同线程持有对方的锁，多个线程又不能释放锁，即产生死锁 类似上图，P1 申请 输出设备，但是输出设备被P2占有，P2又申请输入设备 输入设备又被P1占有形成回路 如何避免呢？ 和简单只要在资源分配前检测当前系统是否处于安全状态，是否能被分配，分配之后系统是否还是安
操作系统银行家算法模拟实现（C语言版）
闭关修炼——暂退
05-23 8万+
目录 一、实验目的 二、实验内容 三、实验要点说明 银行家算法实例 程序结构 四、实验代码 五、实验运行结果 一、实验目的 通过编写一个模拟动态资源分配的银行家算法程序，进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念，并掌握避免死锁的具体实施方法。 二、实验内容 （1）模拟一个银行家算法： 设置数据结构 设计安全性算法 （2） 初始化时让系统拥有一定的资源 （3） 用键盘输入的方式申请资源 （4）如果预分配后，系统处于安全...
【操作系统】银行家算法的实现
只识闲人不识君博客
06-25 2974
银行家算法对应实验一、银行家算法概念二、实验环境三、实验题目四、实验步骤五、实验代码六、实验结果 一、银行家算法概念 银行家算法（Banker’s Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。 安全序列：如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。安全状态一定是没有死锁发生。 不安全状序列：不存在一个安全序列。不安
C语言实现的操作系统银行家算法
流楚丶格念的博客
12-19 1万+
文章目录一、银行家算法二、方案分析三、开发环境四、设计思想及实验步骤4.1 设计思想4.2 银行家算法中的数据结构4.3 银行家算法bank()4.4 安全性算法safe()五、程序的基本结构框图和流程图5.1 程序结构功能图5.2 流程图六、源代码 一、银行家算法 银行家算法（Banker’s Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。 　　在
银行家算法实现（代码全面解析）
07-16
模拟实现Dijkstra的银行家算法以避免死锁的出现.分两部分组成: 第一部分:银行家算法(扫描) 1．如果Request,则转向2;否则,出错 2．如果Request,则转向3,否则等待 3．系统试探分配请求的资源给进程 4．系统...
用java实现操作系统实验银行家算法
05-26
要解释银行家算法，必须先解释操作系统安全状态和不安全状态。 安全序列是指一个进程序列{P1，…，Pn}是安全的，即对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j )当前...
操作系统银行家算法避免死锁
06-17
银行家算法避免死锁 VM软件 Linux系统 C语言 成功编译 成功运行 内附完整课设报告，代码，运行cpp 附有哲学家进餐简略一题 原课设要求：死锁避免 （1）请设计一个程序演示死锁避免算法（银行家算法）。 （2）要求该...
操作系统之银行家算法源代码
01-20
银行家算法是避免死锁的一种重要方法，本程序用java编程语言对其进行了实现。 当用户申请一组资源时，系统必须做出判断，如果把这些资源分出去，系统是否还处于安全状态。 若是，就可以分出这些资源；否则，该申请暂...
银行家算法源代码
06-16
银行家算法<br>c++源代码
JAVA操作系统课设作业银行家算法图形化模拟程序
01-10
**JAVA操作系统课设作业银行家算法图形化模拟程序** 银行家算法是一种著名的避免死锁的策略，由艾兹格·迪杰斯特拉在1965年提出。它主要用于操作系统中资源分配，确保系统能够避免资源饥饿和系统崩溃。在这个JAVA16...
操作系统实验（三）：c实现银行家算法的资源分配
le000426的博客
06-14 1461
操作系统（三）：c实现银行家算法的资源分配
银行家算法实现（操作系统实验）
m0_53112875的博客
05-23 1949
#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]; .
Android多进程加载资源失败问题分析:android.content.res.Resources$NotFoundException: Resource ID #0x7f08XXXX
zhanghao_Hulk的专栏
09-08 1912
在Android开发中如果存在多进程共享资源用法时, 会出现资源到不到问题. 真实碰到的问题, 记录下来提供同学们参考 一, 崩溃信息 崩溃日志如下 --------- beginning of crash 08-17 18:54:00.622 17167 17167 E AndroidRuntime: FATAL EXCEPTION: main 08-17 18:54:00.622 17167 17167 E AndroidRuntime: Process: com.mobile.emm.trus
银行家算法实现代码
jakelihua
12-25 581
银行家算法Java实现
计算机操作系统_银行家算法
热门推荐
魏宇轩
12-05 21万+
银行家算法
操作系统课程设计银行家算法
wangiijing的博客
05-19 4858
#include #include using namespace std; typedef struct Arithmetic { char name; int Max[5]; int Allocation[5]; int Need[5]; int OP; }ari; typedef struct In { ari a[5]; int size; }in; int avi[5]
操作系统实验银行家算法c语言代码
05-09
下面是一个简单的 C 语言实现银行家算法的代码： ```c #include <stdio.h> #include <stdbool.h> // 定义最大进程数和资源数 #define MAX_PROCESS 10 #define MAX_RESOURCE 10 // 进程结构体 typedef struct process { int id; // 进程 ID int allocation[MAX_RESOURCE]; // 当前占用资源 int max_demand[MAX_RESOURCE]; // 最大需求资源 int need[MAX_RESOURCE]; // 还需要的资源 bool finished; // 进程是否完成 } Process; // 系统资源结构体 typedef struct system_resource { int available[MAX_RESOURCE]; // 系统可用资源数量 int max_resources[MAX_RESOURCE]; // 系统总资源数量 } SysResource; // 初始化系统资源 void init_sys_resource(SysResource *sys_res) { printf("请输入系统资源总量："); for (int i = 0; i < MAX_RESOURCE; i++) { scanf("%d", &sys_res->max_resources[i]); sys_res->available[i] = sys_res->max_resources[i]; } } // 初始化进程 void init_process(Process *processes, int process_num, int resource_num) { printf("请输入每个进程的最大需求量和当前已占用量：\n"); for (int i = 0; i < process_num; i++) { processes[i].id = i; processes[i].finished = false; printf("进程 %d：\n", i); for (int j = 0; j < resource_num; j++) { scanf("%d", &processes[i].max_demand[j]); scanf("%d", &processes[i].allocation[j]); processes[i].need[j] = processes[i].max_demand[j] - processes[i].allocation[j]; } } } // 判断当前请求的资源是否合法 bool is_safe_state(SysResource *sys_res, Process *processes, int process_num, int resource_num, int id, int *request) { int work[MAX_RESOURCE]; bool finish[MAX_PROCESS]; for (int i = 0; i < MAX_RESOURCE; i++) { work[i] = sys_res->available[i]; } for (int i = 0; i < MAX_PROCESS; i++) { finish[i] = processes[i].finished; } for (int i = 0; i < MAX_RESOURCE; i++) { if (request[i] > processes[id].need[i] || request[i] > sys_res->available[i]) { return false; } } for (int i = 0; i < MAX_RESOURCE; i++) { processes[id].allocation[i] += request[i]; processes[id].need[i] -= request[i]; sys_res->available[i] -= request[i]; work[i] = sys_res->available[i]; } while (true) { bool flag = false; for (int i = 0; i < MAX_PROCESS; i++) { if (!finish[i]) { bool can_finish = true; for (int j = 0; j < MAX_RESOURCE; j++) { if (processes[i].need[j] > work[j]) { can_finish = false; break; } } if (can_finish) { finish[i] = true; flag = true; for (int j = 0; j < MAX_RESOURCE; j++) { work[j] += processes[i].allocation[j]; } } } } if (!flag) { break; } } for (int i = 0; i < MAX_RESOURCE; i++) { processes[id].allocation[i] -= request[i]; processes[id].need[i] += request[i]; sys_res->available[i] += request[i]; } for (int i = 0; i < MAX_PROCESS; i++) { if (!finish[i]) { return false; } } return true; } // 请求资源 void request_resource(SysResource *sys_res, Process *processes, int process_num, int resource_num) { int id; int request[MAX_RESOURCE]; printf("请输入请求资源的进程 ID："); scanf("%d", &id); printf("请输入请求的资源量："); for (int i = 0; i < MAX_RESOURCE; i++) { scanf("%d", &request[i]); } if (is_safe_state(sys_res, processes, process_num, resource_num, id, request)) { printf("该请求是安全的，已分配资源！\n"); for (int i = 0; i < MAX_RESOURCE; i++) { sys_res->available[i] -= request[i]; processes[id].allocation[i] += request[i]; processes[id].need[i] -= request[i]; } } else { printf("该请求不安全，无法分配资源！\n"); } } // 释放资源 void release_resource(SysResource *sys_res, Process *processes, int process_num, int resource_num) { int id; int release[MAX_RESOURCE]; printf("请输入释放资源的进程 ID："); scanf("%d", &id); printf("请输入释放的资源量："); for (int i = 0; i < MAX_RESOURCE; i++) { scanf("%d", &release[i]); } for (int i = 0; i < MAX_RESOURCE; i++) { processes[id].allocation[i] -= release[i]; processes[id].need[i] += release[i]; sys_res->available[i] += release[i]; } printf("资源已释放！\n"); } // 显示当前资源状态 void display_resource(SysResource *sys_res, Process *processes, int process_num, int resource_num) { printf("当前系统资源状态：\n"); printf("可用资源量："); for (int i = 0; i < MAX_RESOURCE; i++) { printf("%d ", sys_res->available[i]); } printf("\n"); printf("最大资源量："); for (int i = 0; i < MAX_RESOURCE; i++) { printf("%d ", sys_res->max_resources[i]); } printf("\n"); printf("进程占用资源量：\n"); for (int i = 0; i < process_num; i++) { printf("进程 %d：", processes[i].id); for (int j = 0; j < resource_num; j++) { printf("%d ", processes[i].allocation[j]); } printf("\n"); } } int main() { SysResource sys_res; Process processes[MAX_PROCESS]; int process_num, resource_num; printf("请输入进程数："); scanf("%d", &process_num); printf("请输入资源数："); scanf("%d", &resource_num); init_sys_resource(&sys_res); init_process(processes, process_num, resource_num); while (true) { printf("\n请选择要进行的操作：\n"); printf("1. 请求资源\n"); printf("2. 释放资源\n"); printf("3. 显示当前资源状态\n"); printf("4. 退出\n"); int choice; scanf("%d", &choice); switch (choice) { case 1: request_resource(&sys_res, processes, process_num, resource_num); break; case 2: release_resource(&sys_res, processes, process_num, resource_num); break; case 3: display_resource(&sys_res, processes, process_num, resource_num); break; case 4: return 0; default: printf("请输入正确的操作！\n"); } } } ``` 这个代码实现了银行家算法的基本功能，包括初始化系统资源和进程，请求资源，释放资源，显示当前资源状态等。需要注意的是，这个代码只是一个简单的示例，并没有考虑多线程等实际情况下的实现细节。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 21
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值