银行家算法

最新推荐文章于 2023-04-16 20:01:55 发布
最新推荐文章于 2023-04-16 20:01:55 发布
阅读量201 收藏 1
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44266050/article/details/102810878
版权

文章目录

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
using namespace std;
#define MAXSIZE 10
int n, m;//n是进程数，m是资源数
typedef struct{
	int Max[MAXSIZE][MAXSIZE];
	int Allocation[MAXSIZE][MAXSIZE];
	int Need[MAXSIZE][MAXSIZE];
	int program;
	int resource;
	int Available[MAXSIZE];
}BANK;

//输入条件
void init(BANK &banker){
	printf("进程数：");
	scanf("%d", &n);
	printf("资源数：");
	scanf("%d", &m);
	banker.program = n; banker.resource = m;

	printf("可利用资源：");
	for (int i = 0; i < banker.resource; i++)
		scanf("%d", &banker.Available[i]);
	
	printf("最大需求矩阵:\n");
	for (int i = 0; i < banker.program; i++){
		printf("进程P%d:", i);
		for (int j = 0; j < banker.resource; j++){
			scanf("%d", &banker.Max[i][j]);
		}
	}

	printf("分配矩阵:\n");
	for (int i = 0; i < banker.program; i++){
		printf("进程P%d:", i);
		for (int j = 0; j < banker.resource; j++){
			scanf("%d", &banker.Allocation[i][j]);
			//需求矩阵
			banker.Need[i][j] = banker.Max[i][j] - banker.Allocation[i][j];
			//还剩的可利用资源
			banker.Available[j] -= banker.Allocation[i][j];
		}
	}

	return;
}

//展示当前资源分配表
void shownow(BANK banker){
	printf("当前时刻资源分配表\n进程     Max        Allocation        Need        Available\n");//5，8，8，8
	int pause = 11 - banker.resource * 2;//空格，美观的的，没用
	for (int i = 0; i < banker.program; i++){
		printf("P%d       ", i);//空格7个
		for (int j = 0; j < banker.resource; j++)
			printf("%d ", banker.Max[i][j]);
		for (int j = 0; j < pause;j++)//对齐
		printf(" ");
		for (int j = 0; j < banker.resource; j++)
			printf("%d ", banker.Allocation[i][j]);
		for (int j = 0; j < (pause+7); j++)//对齐
			printf(" ");
		for (int j = 0; j < banker.resource; j++)
			printf("%d ", banker.Need[i][j]);
		if (i == 0){
			for (int j = 0; j < (pause + 1); j++)//对齐
				printf(" ");
			for (int j = 0; j < banker.resource; j++)
				printf("%d ", banker.Available[j]);
		}
			
		printf("\n");
	}
}
//展示当前的安全序列
void showSafe(int *safe, int Work[], BANK banker){
	printf("当前时刻安全序列\n进程     Work        Need        Allocation        Work+Allocation");
	int t = banker.program,k=0;
	int pause = 12 - banker.resource * 2;//空格，美观的的，没用
	for (int i = 0; i < banker.resource; i++)
		Work[i] = banker.Available[i];
	int temp;
	while (t--){
		temp = *(safe + k++);//进程号
		printf("\nP%d       ", temp);//空格7个
		for (int j = 0; j < banker.resource; j++)
			printf("%d ", Work[j]);
		for (int j = 0; j < pause; j++)//对齐
			printf(" ");
		for (int j = 0; j < banker.resource; j++)
			printf("%d ", banker.Need[temp][j]);
		for (int j = 0; j < pause; j++)//对齐
			printf(" ");
		for (int j = 0; j < banker.resource; j++){
			printf("%d ", banker.Allocation[temp][j]);
			Work[j] += banker.Allocation[temp][j];
		}
		for (int j = 0; j < (pause+6); j++)//对齐
			printf(" ");
		for (int j = 0; j < banker.resource; j++)
			printf("%d ", Work[j]);
	}
	printf("\n");
	return;
}

//比较a[]<=b[]是否都满足，多处应用到
bool compare(int a[], int b[]){
	for (int i = 0; i < m; i++){
		if (a[i]>b[i])return false;
	}
	return true;
}
//是否所有Finish[i]=true都满足
bool comp(bool a[]){
	for (int i = 0; i < n; i++)
		if (!a[i])return false;
	return true;
}

//分配
void GiveTo(BANK &banker,int pro[],int pro_id){
	for (int i = 0; i < banker.resource; i++){
		banker.Available[i] -= pro[i];
		banker.Allocation[pro_id][i] += pro[i];
		banker.Need[pro_id][i] -= pro[i];
	}
	return;
}
//取消分配
void GiveOut(BANK &banker, int pro[], int pro_id){
	for (int i = 0; i < banker.resource; i++){
		banker.Available[i] += pro[i];
		banker.Allocation[pro_id][i] -= pro[i];
		banker.Need[pro_id][i] += pro[i];
	}
	return;
}

//判断是否有进程达到最大需求，有就释放给它的资源，返回释放的进程号
int finishdoult(BANK &banker){
	int fh = -1;
	//判断是否有进程达到最大需求,fh记录进程号
	for (int i = 0; i < banker.program; i++){
		if (banker.Need[i][0] == 0){
			int j;
			for (j = 1; j < banker.resource; j++)
				if (banker.Need[i][j])break;
			if (j == banker.resource){
				fh = i; break;
			}
		}
	}

	if (fh == -1)return fh;
	for (int i = 0; i < banker.resource; i++){
		banker.Need[fh][i] = banker.Max[fh][i];
		banker.Allocation[fh][i] = 0;
		banker.Available[i] += banker.Max[fh][i];
	}
	return fh;
}

//只要有满足条件的执行即可，毕竟执行完可利用的资源只会变多
//安全性算法（银行家算法的步骤（4））
bool Savedoult(BANK banker,int *&safe){
	//3.1设置两个向量
	int Work[MAXSIZE],k=0;//k是保存安全序列的下标
	for (int i = 0; i < banker.resource; i++)
		Work[i] = banker.Available[i];
	bool Finish[MAXSIZE] = { false };

	//3.2：找一个满足条件的
	for (int i = 0; i < banker.program; i++){
		//找到，执行3.3
		if (!Finish[i] && compare(banker.Need[i], Work)){
			for (int j = 0; j < banker.resource; j++)
				Work[j] += banker.Allocation[i][j];
			Finish[i] = true;
			*(safe+k++) = i;//存入安全序列
			i = -1;//找到一个之后再从0开始循环(循环结束会++所以要设-1）
		}
		//没找到，执行3.4
		else{
			if (!comp(Finish))continue;
			//如果都满足了即安全，展示安全序列并返回true
			showSafe(safe, Work, banker);
			return true;
		}
	}
	//找不到安全序列则不安全
	return false;
}

//银行家算法
void banksafe(BANK &banker,int *safe){
	//步骤（0）请求（这里默认输入进程-1则退出）
	int pro_id, pro[MAXSIZE];
	printf("\n（-1则退出）进程：");
	cin >> pro_id;

	while (pro_id != -1){
		if (pro_id < 0 || pro_id >= banker.program){
			printf("超出进程数量限制\n进程：");
			cin >> pro_id;
			continue;
		}
		printf("进程P%d的请求变量：", pro_id);
		for (int i = 0; i < banker.resource; i++)
			scanf("%d", &pro[i]);

		//步骤（1）
		if (!compare(pro, banker.Need[pro_id])){
			printf("超出它所宣布的最大值\n进程：");
			cin >> pro_id;
			continue;
		}

		//步骤（2）
		if (!compare(pro, banker.Available)){
			printf("尚无足够资源，需等待\n进程：");
			cin >> pro_id;
			continue;
		}

		//步骤（3）试探的分配
		GiveTo(banker, pro, pro_id);

		//步骤（4）安全性算法
		if (Savedoult(banker, safe)){//若安全，正式分配，本次分配完成，输出安全序列和分配过后的资源分配表
			printf("安全\n安全序列：");
			for (int i = 0; i < banker.program; i++)
				printf("%d ", *(safe + i));
			printf("\n");
			int fh = finishdoult(banker);//是否有运行完毕的进程
			if (fh != -1){
				printf("进程P%d已运行完成，释放出分配给它的资源\n",fh);
			}
			shownow(banker);//展示当前资源分配表（运行完的释放，重新等待）
			printf("\n");
		}
		else{//若不安全，恢复原来的资源分配状态，等待该进程，执行其他的申请
			printf("不安全\n");
			GiveOut(banker, pro, pro_id);//取消分配
		}

		//步骤（0）请求
		printf("\n进程：");
		cin >> pro_id;

	}
	return;
}
int main(){
	BANK banker;
	init(banker);

	//判断当前时刻是否安全
	int *safe=(int*)malloc(n*sizeof(int));
	if (Savedoult(banker, safe)){
		printf("安全\n安全序列：");
		for (int i = 0; i < banker.program; i++)
			printf("%d ", *(safe + i));
		int fh = finishdoult(banker);//是否有运行完毕的进程
		if (fh != -1){
			printf("进程P%d已运行完成，释放出分配给它的资源\n", fh);
		}
		shownow(banker);//展示当前资源分配表（运行完的释放，重新等待）
		printf("\n");
	}
	else
		printf("不安全\n");

	banksafe(banker, safe);

	system("PAUSE");
	return 0;
}

0.结构体

#define MAXSIZE 10
int n, m;//n是进程数，m是资源数
typedef struct{
	int Max[MAXSIZE][MAXSIZE];
	int Allocation[MAXSIZE][MAXSIZE];
	int Need[MAXSIZE][MAXSIZE];
	int program;
	int resource;
	int Available[MAXSIZE];
}BANK;

1.输入条件

//输入条件
void init(BANK &banker){
	printf("进程数：");
	scanf("%d", &n);
	printf("资源数：");
	scanf("%d", &m);
	banker.program = n; banker.resource = m;

	printf("可利用资源：");
	for (int i = 0; i < banker.resource; i++)
		scanf("%d", &banker.Available[i]);
	
	printf("最大需求矩阵:\n");
	for (int i = 0; i < banker.program; i++){
		printf("进程P%d:", i);
		for (int j = 0; j < banker.resource; j++){
			scanf("%d", &banker.Max[i][j]);
		}
	}

	printf("分配矩阵:\n");
	for (int i = 0; i < banker.program; i++){
		printf("进程P%d:", i);
		for (int j = 0; j < banker.resource; j++){
			scanf("%d", &banker.Allocation[i][j]);
			//需求矩阵
			banker.Need[i][j] = banker.Max[i][j] - banker.Allocation[i][j];
			//还剩的可利用资源
			banker.Available[j] -= banker.Allocation[i][j];
		}
	}

	return;
}

2.展示当前时刻的资源分配表和安全序列

（安全序列的Work是在安全性算法中定义的，只能在安全性算法中引用）

//展示当前资源分配表
void shownow(BANK banker){
	printf("当前时刻资源分配表\n进程     Max        Allocation        Need        Available\n");//5，8，8，8
	int pause = 11 - banker.resource * 2;//空格，美观的的，没用
	for (int i = 0; i < banker.program; i++){
		printf("P%d       ", i);//空格7个
		for (int j = 0; j < banker.resource; j++)
			printf("%d ", banker.Max[i][j]);
		for (int j = 0; j < pause;j++)//对齐
		printf(" ");
		for (int j = 0; j < banker.resource; j++)
			printf("%d ", banker.Allocation[i][j]);
		for (int j = 0; j < (pause+7); j++)//对齐
			printf(" ");
		for (int j = 0; j < banker.resource; j++)
			printf("%d ", banker.Need[i][j]);
		if (i == 0){
			for (int j = 0; j < (pause + 1); j++)//对齐
				printf(" ");
			for (int j = 0; j < banker.resource; j++)
				printf("%d ", banker.Available[j]);
		}
			
		printf("\n");
	}
}
//展示当前的安全序列
void showSafe(int *safe, int Work[], BANK banker){
	printf("当前时刻安全序列\n进程     Work        Need        Allocation        Work+Allocation");
	int t = banker.program,k=0;
	int pause = 12 - banker.resource * 2;//空格，美观的的，没用
	for (int i = 0; i < banker.resource; i++)
		Work[i] = banker.Available[i];
	int temp;
	while (t--){
		temp = *(safe + k++);//进程号
		printf("\nP%d       ", temp);//空格7个
		for (int j = 0; j < banker.resource; j++)
			printf("%d ", Work[j]);
		for (int j = 0; j < pause; j++)//对齐
			printf(" ");
		for (int j = 0; j < banker.resource; j++)
			printf("%d ", banker.Need[temp][j]);
		for (int j = 0; j < pause; j++)//对齐
			printf(" ");
		for (int j = 0; j < banker.resource; j++){
			printf("%d ", banker.Allocation[temp][j]);
			Work[j] += banker.Allocation[temp][j];
		}
		for (int j = 0; j < (pause+6); j++)//对齐
			printf(" ");
		for (int j = 0; j < banker.resource; j++)
			printf("%d ", Work[j]);
	}
	printf("\n");
	return;
}

3.分配和取消分配

//分配
void GiveTo(BANK &banker,int pro[],int pro_id){
	for (int i = 0; i < banker.resource; i++){
		banker.Available[i] -= pro[i];
		banker.Allocation[pro_id][i] += pro[i];
		banker.Need[pro_id][i] -= pro[i];
	}
	return;
}
//取消分配
void GiveOut(BANK &banker, int pro[], int pro_id){
	for (int i = 0; i < banker.resource; i++){
		banker.Available[i] += pro[i];
		banker.Allocation[pro_id][i] -= pro[i];
		banker.Need[pro_id][i] += pro[i];
	}
	return;
}

4.两个比较函数，是否有运行完毕的进程

//比较a[]<=b[]是否都满足，多处应用到
bool compare(int a[], int b[]){
	for (int i = 0; i < m; i++){
		if (a[i]>b[i])return false;
	}
	return true;
}
//是否所有Finish[i]=true都满足
bool comp(bool a[]){
	for (int i = 0; i < n; i++)
		if (!a[i])return false;
	return true;
}
//判断是否有进程达到最大需求，有就释放给它的资源，返回释放的进程号
int finishdoult(BANK &banker){
	int fh = -1;
	//判断是否有进程达到最大需求,fh记录进程号
	for (int i = 0; i < banker.program; i++){
		if (banker.Need[i][0] == 0){
			int j;
			for (j = 1; j < banker.resource; j++)
				if (banker.Need[i][j])break;
			if (j == banker.resource){
				fh = i; break;
			}
		}
	}

	if (fh == -1)return fh;
	for (int i = 0; i < banker.resource; i++){
		banker.Need[fh][i] = banker.Max[fh][i];
		banker.Allocation[fh][i] = 0;
		banker.Available[i] += banker.Max[fh][i];
	}
	return fh;
}

5.安全性算法（银行家算法的步骤4）

只要有满足条件的执行即可，毕竟执行完可利用的资源只会变多
在这里插入图片描述

bool Savedoult(BANK banker,int *&safe){
	//3.1设置两个向量
	int Work[MAXSIZE],k=0;//k是保存安全序列的下标
	for (int i = 0; i < banker.resource; i++)
		Work[i] = banker.Available[i];
	bool Finish[MAXSIZE] = { false };

	//3.2：找一个满足条件的
	for (int i = 0; i < banker.program; i++){
		//找到，执行3.3
		if (!Finish[i] && compare(banker.Need[i], Work)){
			for (int j = 0; j < banker.resource; j++)
				Work[j] += banker.Allocation[i][j];
			Finish[i] = true;
			*(safe+k++) = i;//存入安全序列
			i = -1;//找到一个之后再从0开始循环(循环结束会++所以要设-1）
		}
		//没找到，执行3.4
		else{
			if (!comp(Finish))continue;
			//如果都满足了即安全，展示安全序列并返回true
			showSafe(safe, Work, banker);
			return true;
		}
	}
	//找不到安全序列则不安全
	return false;
}

6.银行家算法

在这里插入图片描述

//银行家算法
void banksafe(BANK &banker,int *safe){
	//步骤（0）请求（这里默认输入进程-1则退出）
	int pro_id, pro[MAXSIZE];
	printf("\n（-1则退出）进程：");
	cin >> pro_id;

	while (pro_id != -1){
		if (pro_id < 0 || pro_id >= banker.program){
			printf("超出进程数量限制\n进程：");
			cin >> pro_id;
			continue;
		}
		printf("进程P%d的请求变量：", pro_id);
		for (int i = 0; i < banker.resource; i++)
			scanf("%d", &pro[i]);

		//步骤（1）
		if (!compare(pro, banker.Need[pro_id])){
			printf("超出它所宣布的最大值\n进程：");
			cin >> pro_id;
			continue;
		}

		//步骤（2）
		if (!compare(pro, banker.Available)){
			printf("尚无足够资源，需等待\n进程：");
			cin >> pro_id;
			continue;
		}

		//步骤（3）试探的分配
		GiveTo(banker, pro, pro_id);

		//步骤（4）安全性算法
		if (Savedoult(banker, safe)){//若安全，正式分配，本次分配完成，输出安全序列和分配过后的资源分配表
			printf("安全\n安全序列：");
			for (int i = 0; i < banker.program; i++)
				printf("%d ", *(safe + i));
			printf("\n");
			int fh = finishdoult(banker);//是否有运行完毕的进程
			if (fh != -1){
				printf("进程P%d已运行完成，释放出分配给它的资源\n",fh);
			}
			shownow(banker);//展示当前资源分配表（运行完的释放，重新等待）
			printf("\n");
		}
		else{//若不安全，恢复原来的资源分配状态，等待该进程，执行其他的申请
			printf("不安全\n");
			GiveOut(banker, pro, pro_id);//取消分配
		}

		//步骤（0）请求
		printf("\n进程：");
		cin >> pro_id;

	}
	return;
}

7.主函数

int main(){
	BANK banker;
	init(banker);

	//判断当前时刻是否安全
	int *safe=(int*)malloc(n*sizeof(int));
	if (Savedoult(banker, safe)){
		printf("安全\n安全序列：");
		for (int i = 0; i < banker.program; i++)
			printf("%d ", *(safe + i));
		int fh = finishdoult(banker);//是否有运行完毕的进程
		if (fh != -1){
			printf("进程P%d已运行完成，释放出分配给它的资源\n", fh);
		}
		shownow(banker);//展示当前资源分配表（运行完的释放，重新等待）
		printf("\n");
	}
	else
		printf("不安全\n");

	banksafe(banker, safe);

	system("PAUSE");
	return 0;
}
Deosiree
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
操作系统银行家算法 js网页实现
12-26
大学生——操作系统课程——银行家算法——JS实现，很简单代码通俗易通，每句话都有注释
1.1.2.6 银行家算法
xiaowenzi的博客
04-01 320
银行家算法是资源和死锁避免的算法，由艾兹格·迪杰斯特拉（Edsger Dijkstra） 设计的算法用于测已确定总数量的资源分配的安全性，在决定是否该分配应该被允许并进行下去之前，通过“s-state”校验码测试资源分配活动期间产生死锁条件的可能性。 该算法是为为THE操作系统设计并且最在在EWD108描述。当一个新的进程进入系统时，进程必须声明所需每个资源实例最大的数量和类型。显然，资源数...
操作系统第三章：银行家算法
你说的白是什么白_
10-22 2万+
文章目录银行家算法1. 银行家算法中的数据结构2. 银行家算法的处理步骤3. 安全性算法4.举例5.银行家算法总结 银行家算法 银行家算法是最有代表性的避免死锁的算法。 由于该算法能用于银行系统现金贷款的发放而得名的。 1. 银行家算法中的数据结构 设系统中有m类资源，n个进程 （1）可利用资源向量Available。含有m个元素的一维数组，每个元素代表一类可利用的资源数目。 如果Available[j]=k,表示系统中现有Rj类资源k个。 （2）最大需求矩阵Max， 是一个n*m的矩阵，定义了系统中n个
银行家算法 c语言
mdjsmg的博客
04-16 2753
操作系统学习之银行家算法，c语言代码实现
操作系统银行家算法避免死锁
06-17
银行家算法避免死锁 VM软件 Linux系统 C语言 成功编译 成功运行 内附完整课设报告，代码，运行cpp 附有哲学家进餐简略一题 原课设要求：死锁避免 （1）请设计一个程序演示死锁避免算法（银行家算法）。 （2）要求该...
银行家算法模拟实验
04-21
银行家算法是从当前状态出发，逐个按安全序列检查各客户中谁能完成其工作，然后假定其完成工作且归还全部贷款，再进而检查下一个能完成工作的客户。如果所有客户都能完成工作，则找到一个安全序列，银行家才是安全的...
使用java实现银行家算法
08-25
主要为大家详细介绍了如何使用java实现银行家算法，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
银行家算法python实现
03-26
保证能跑
操作系统银行家算法
06-10
简单模拟银行家算法，实现了银行家算法的模拟，具有小规模学习的作用
银行家算法C语言代码.doc
05-18
银行家算法C语言代码 银行家算法是操作系统中的一种资源分配算法，用于避免死锁的产生。该算法通过跟踪每个进程的资源需求和当前可用的资源量来避免死锁的产生。 在本文档中，我们提供了银行家算法的C语言代码实现...
银行家算法模拟实现
06-09
本设计应用银行家算法验证进程安全性检查及分配资源，设计资源利用效率算法对安全序列排序。目的是通过编写和调试一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并采用适当的算法，有效地防止和避免死锁...
银行家算法模拟_银行家算法_
09-29
银行家算法模拟实现(C语言)，操作系统原理课程上机练习
操作系统实验之银行家算法
05-22
银行家算法 一，实验目的 1，掌握银行家安全性算法和资源请求算法的原理 2，掌握银行家算法的实现方法 二，基本概念 在银行中，客户申请贷款的数量是有限的，每个客户在第一次申请贷款时要声明完成该项目所需的最大...
操作系统实验报告
m0_70350178的博客
06-06 3386
利用C++设计实现银行家算法的基本过程。
银行家算法( 详解 )
热门推荐
Bit_Dong的博客
07-22 4万+
银行家算法是操作系统的经典算法之一，用于避免死锁情况的出现。它最初是为银行设计的（因此得名），通过判断借贷是否安全，然后决定借不借。在银行中，客户申请贷款的数量是有限的，每个客户在第一次申请贷款时要声明完成该项目所需的最大资金量，在满足所有贷款要求时，客户应及时归还。银行家在客户申请的贷款数量不超过自己拥有的最大值时，都应尽量满足客户的需要。用在操作系统中，银行家、出借资金、客户，就分别对应操作系统、资源、申请资源的进程。...
银行家算法(一看就懂)
小白的Coding之旅
02-13 1632
pycham银行家算法
最新发布
05-23
银行家算法（Banker's Algorithm）是一种避免死锁的算法，主要用于操作系统中的进程调度。它通过预先计算系统资源分配的安全性来决定是否分配资源，以避免死锁的发生。在 PyCharm 中，银行家算法可以用来解决多线程...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Deosiree

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值