C++操作系统之银行家算法

最新推荐文章于 2024-04-25 17:25:52 发布
最新推荐文章于 2024-04-25 17:25:52 发布
阅读量797 收藏 9
点赞数 2
文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Alanmian/article/details/130548169
版权

银行家算法：
主要考虑进程能不能正常分配的问题，即剩余资源该先分配谁，分配了后能不能让它执行完，执行完返回的资源又该继续分给谁的问题，最后看能不能所有进程都分配到资源执行完。执行完了会有安全序列
但是安全序列不唯一！
主要逻辑：
第一点：进程初始化的时候 Allocation资源 <= Max资源； Need+Allocation资源 <= MAX资源 这个是必须要保证的，超过了就没意义了。
第二点：当第一次执行算法时就无法得出安全序列，则不用考虑有别的进程临时申请资源了！
第三点：当首次算法执行完后，能得出安全序列，能首次Request资源时用的资源表是初始化的资源表这是要理清楚的，后面Request申请的则用上一次的资源申请表所以要考虑好资源表的保存以及复用，还有要做好Allocation，Need，Available的保存，复用以及还原，要做还原这个在下一点讲。
第四点：进程临时资源申请有两大条件需要满足 ①Request<=Need ②Request<=Available
当进程满足这两个条件时，Allocation + Request；Need - Request; Available - Request；但是当资源满足但又无法得出安全序列的时候则需要把这些都复原，即上述所说要做好原资源量的保存
代码区：

#include<iostream>
#include<queue>
using namespace std;
struct PCB {
	string Name;
	int Max[1][3];
	int Allocation[1][3];
	int Need[1][3];
	int Work[1][3];
	int endResource[1][3];//Work+Allocation
	string finish;
};
int Available[1][3];
int reAvailable[1][3];
int useCount = 0;
queue<PCB>readList;
queue<PCB>temp_ReadList;
//显示录入数据的当前量
void showInitData(queue<PCB>q) {
	queue<PCB>temp;
	temp = q;
	cout << "------------------------------------------数据初始状态------------------------------------------" << endl;
	cout << "进程名\t" << "进程Max量\t" << "进程Allcation量\t" << "     进程Need量\t" << "      进程Work\t" << "  进程状态" << endl;
	while (q.size() != 0) {
		cout << q.front().Name << "\t " << q.front().Max[0][0] << " " << q.front().Max[0][1] << " " << q.front().Max[0][2] << "\t\t    "
			<< q.front().Allocation[0][0] << " " << q.front().Allocation[0][1] << " " << q.front().Allocation[0][2] << "\t\t"
			<< q.front().Need[0][0] << " " << q.front().Need[0][1] << " " << q.front().Need[0][2] << "\t\t"
			<< q.front().Work[0][0] << " " << q.front().Work[0][1] << " " << q.front().Work[0][2] << "\t   "
			<< q.front().finish << endl;
		q.pop();
	}
	cout << "------------------------------------------------------------------------------------------------" << endl;
	q = temp;
}

//展示能否成功执行
void showData(queue<PCB>& q) {
	queue<PCB>temp;
	temp = q;
	cout << "------------------------------------------数据完毕状态------------------------------------------" << endl;
	cout << "进程名\t" << "进程Work量\t"  << "进程Need量\t"  << "进程Allcation量\t" << "  进程Work+Allocation\t" << "进程状态" << endl;
	while (q.size() != 0) {
		cout << q.front().Name << "\t " << q.front().Work[0][0] << " " << q.front().Work[0][1] << " " << q.front().Work[0][2] << "\t\t   "
			<< q.front().Need[0][0] << " " << q.front().Need[0][1] << " " << q.front().Need[0][2] << "\t    "
			<< q.front().Allocation[0][0] << " " << q.front().Allocation[0][1] << " " << q.front().Allocation[0][2] << "\t\t"
			<< q.front().endResource[0][0] << " " << q.front().endResource[0][1] << " " << q.front().endResource[0][2] << "\t\t "
			<< q.front().finish << endl;
		q.pop();
	}
	cout << "------------------------------------------------------------------------------------------------" << endl;
	q = temp;
}

//输出安全序列
void showSafeQueue(queue<PCB>& q) {
	queue<PCB>temp;
	temp = q;
	cout << "安全序列为：";
	while (q.size() != 0) {
		cout << q.front().Name;
		q.pop();
		if (q.size() != 0) {
			cout << "->";
		}
	}
	cout << endl;
	q = temp;
}

void InitPCB() {
	PCB p;
	int sum;
	cout << "请输入进程个数：";
	cin >> sum;
	for (int i = 1; i <= sum; i++) {
		cout << "请输入进程名字：";
		cin >> p.Name;
		cout << "请输入" << p.Name << "所需的最大资源量Max例如(1  2  3)：";
		cin >> p.Max[0][0] >> p.Max[0][1] >> p.Max[0][2];
		cout << "请输入" << p.Name << "已分配的资源量Allocation例如(1  2  3):";
		while (1) {
			cin >> p.Allocation[0][0] >> p.Allocation[0][1] >> p.Allocation[0][2];
			if ((p.Max[0][0] < p.Allocation[0][0]) < (p.Max[0][1] < p.Allocation[0][1]) || (p.Max[0][2] < p.Allocation[0][2])) {
				cout <<p.Name<< "的Allocation输入有误不能大于Max资源量！！！请重新输入格式(1  2  3):" << endl;
				cin >> p.Allocation[0][0] >> p.Allocation[0][1] >> p.Allocation[0][2];
			}
			else {
				break;
			}
		}

		cout << "请输入" << p.Name << "还需要申请的资源量Need例如(1  2  3):";
		while (1) {
			cin >> p.Need[0][0] >> p.Need[0][1] >> p.Need[0][2];
			if ((p.Max[0][0] < p.Allocation[0][0] + p.Need[0][0]) < (p.Max[0][1] < p.Allocation[0][1] + p.Need[0][1]) || (p.Max[0][2] < p.Allocation[0][2] + p.Need[0][2])) {
				cout << p.Name << "的Need输入有误Allocation+Need不能大于Max资源量！！！请重新输入格式(1  2  3):" << endl;
				cin >> p.Need[0][0] >> p.Need[0][1] >> p.Need[0][2];
			}
			else {
				break;
			}
		}
		p.Work[0][0] = p.Work[0][1] = p.Work[0][2] = 0;
		p.endResource[0][0] = p.endResource[0][1] = p.endResource[0][2] = 0;
		p.finish = "false";
		//放入容器中
		readList.push(p);
	}
	//作为永久的一个数据存储量 不改变的。
	temp_ReadList = readList;
	//显示录入值的情况
	showInitData(readList);
}

//只查找有没有这个名字
//防止有人输错名字；
bool Find_Name(string name, queue<PCB>& q) {
	string endName;
	//最后一个数据的名字
	endName = q.back().Name;
	while (q.size()!=0) {
		if (name == q.front().Name) {
			return true;
		}
		else {
			if (q.front().Name == endName) {
				return false;
			}
			q.push(q.front());
			q.pop();
		}
	}
}

//按名字查找并做操作
bool Find_PCB_ofName(string name,queue<PCB>& q) {
		if (name == q.front().Name) {
			//进程资源申请两大因素。1、Request量<=进程需求量 2、Request量<=初始工作资源量
			if (((q.front().Need[0][0] >= reAvailable[0][0]) && (q.front().Need[0][1] >= reAvailable[0][1])
				&& (q.front().Need[0][2] >= reAvailable[0][2])) && ((Available[0][0] >= reAvailable[0][0])
					&& (Available[0][1] >= reAvailable[0][1]) && (Available[0][2] >= reAvailable[0][2]))) {
				//当条件满足则把当前进程名的需求量 - 申请量
				q.front().Need[0][0] = q.front().Need[0][0] - reAvailable[0][0];
				q.front().Need[0][1] = q.front().Need[0][1] - reAvailable[0][1];
				q.front().Need[0][2] = q.front().Need[0][2] - reAvailable[0][2];
				//当前进程名的拥有量 + 申请量 
				q.front().Allocation[0][0] = q.front().Allocation[0][0] + reAvailable[0][0];
				q.front().Allocation[0][1] = q.front().Allocation[0][1] + reAvailable[0][1];
				q.front().Allocation[0][2] = q.front().Allocation[0][2] + reAvailable[0][2];

				showInitData(q);
				return true;
			}
			else {
				return false;
		}
	}
}

bool Algorithm_PCB( int Available[1][3], queue<PCB>& q) {
	queue<PCB>noSafe;
	noSafe = q;
	queue<PCB>endList;
	int count = 0;
	int tempSize=q.size();//查看是否能达到原来队列的总数，如果能则有最少一条安全序列，如果不能则没有安全序列
	for (int i = 0; i < tempSize; i++) {
		while (q.size() != 0) {
			//判断Available是否足够分配给Need的每一部分
			if ((Available[0][0] >= q.front().Need[0][0]) && (Available[0][1] >= q.front().Need[0][1]) && (Available[0][2] >= q.front().Need[0][2])) {
				//把剩余资源里分到work里记录
				q.front().Work[0][0] = Available[0][0];
				q.front().Work[0][1] = Available[0][1];
				q.front().Work[0][2] = Available[0][2];
				
				//满足条件的话就进行工作预算
				q.front().endResource[0][0] = Available[0][0] + q.front().Allocation[0][0];
				q.front().endResource[0][1] = Available[0][1] + q.front().Allocation[0][1];
				q.front().endResource[0][2] = Available[0][2] + q.front().Allocation[0][2];

				//改变当前拥有的资源量
				Available[0][0] = q.front().endResource[0][0];
				Available[0][1] = q.front().endResource[0][1];
				Available[0][2] = q.front().endResource[0][2];
				//完成置换标志位
				q.front().finish = "true";
				endList.push(q.front());
				count++; //防止死循环用
				if (count % tempSize == 0) {
					count = 0;
					break;
				}

				q.pop();
				break;
			}
			else {
				count++;//防止死循环用  只在这里设置会崩溃  没办法只能用两个
				if (count % tempSize==0) {
					count = 0;
					break;
				}
				q.push((q.front()));
				q.pop();
			}
		}
		//count == 0;
	}
	//如果出来量跟原始的队列量相同则有安全序列，如果不同则没有安全序列
	if (endList.size() == tempSize) {
		showData(endList);
		showSafeQueue(endList);
		return true;
	}
	else {
		q = noSafe;
		cout << "没有安全序列！！" << endl;
		cout << "--------------------没有安全序列还没返回资源的情况--------------------" << endl;
		cout << "没有安全序列当前Available：" << Available[0][0] << " " << Available[0][1] << " " << Available[0][2] << endl;
		cout << "---------------------------------------------------------------------" << endl;
		showInitData(q);
		return false;
	}
}

void Continue_Algorithm(queue<PCB>& q) {
	//做数据量保存操作 后续可以一直申请
	int tempCountinueAvailable[1][3];
	string flag;
	//是否继续操作
	while (1) {
		cout << "是否有进程申请资源yes/no:";
		cin >> flag;
		//判断输入的flag是否正确
		while (1) {
			if (flag == "yes" || flag =="YES" || flag == "no" || flag == "NO") {
				break;
			}
			else {
				cout << "输入有误，请重新输入yes/no:";
				cin >> flag;
			}
		}

		//如果输入正确就继续执行下一步
		if (flag == "yes" || flag == "YES") {
			cout << "请输入申请的Available值如(1  2  3)：";
			cin >> reAvailable[0][0] >> reAvailable[0][1] >> reAvailable[0][2];
			
			string Name;
			cout << "是哪个进程申请的:";
			cin >> Name;
			//考虑进程名是否能正确
			while (1) {
				if (Find_Name(Name, q) == true) {
					//如果正确就不用执行这个
					break;
				}
				else {
					cout << "需要分配的进程名有误，请重新输入：";
					cin >> Name;
				}
			}
			
			//找的到名字的话就进行下一步
			//先判定能不能正常分配
			if (Find_PCB_ofName(Name, q) == true) {
				queue<PCB>tempq;
				//如果可以正常分配
				//先存第一次的资源量：
				//找到了名字也要满足资源是是否能分配的情况
				tempCountinueAvailable[0][0] = Available[0][0] = Available[0][0] - reAvailable[0][0];
				tempCountinueAvailable[0][1] = Available[0][1] = Available[0][1] - reAvailable[0][1];
				tempCountinueAvailable[0][2] = Available[0][2] = Available[0][2] - reAvailable[0][2];
				//保存当前的所有数据。
				tempq = q;
				//重复操作计算：
				if (Algorithm_PCB(Available, q) == true) {
					q = tempq;//把前面保存的刷新一下可以继续让下一次申请资源用。
				//把申请后的资源量更新回原状态
					Available[0][0] = tempCountinueAvailable[0][0];
					Available[0][1] = tempCountinueAvailable[0][1];
					Available[0][2] = tempCountinueAvailable[0][2];
					cout << "-------------------------------------------------------" << endl;
					cout << "初始工作Available：" << Available[0][0] << " " << Available[0][1] << " " << Available[0][2] << endl;
					cout << "-------------------------------------------------------" << endl;

					showInitData(q);
				}
				else {
					//返回数据
					Available[0][0] = reAvailable[0][0] + Available[0][0];
					Available[0][1] = reAvailable[0][1] + Available[0][1];
					Available[0][2] = reAvailable[0][2] + Available[0][2];
					cout << "--------------------没有安全序列返回资源的情况--------------------" << endl;
					cout << "当前Available：" << Available[0][0] << " " << Available[0][1] << " " << Available[0][2] << endl;
					cout << "------------------------------------------------------------------" << endl;
				}
				
			}else {
				cout << "-------------------------------------------------------" << endl;
				cout << "申请资源条件不满足！" << endl;
				cout << "-------------------------------------------------------" << endl;

				cout << "-------------------------------------------------------" << endl;
				cout << "当前Available：" << Available[0][0] << " " << Available[0][1] << " " << Available[0][2] << endl;
				cout << "-------------------------------------------------------" << endl;
				
				showInitData(q);
			}	
		}else {
			//如果不用继续执行则退出；
			break;
		}
	}
}

int main() {
	InitPCB();
	int tempAvailable[1][3];
	cout << "请输入Available值如(1  2  3)：";
	cin >> Available[0][0] >> Available[0][1] >> Available[0][2];
	//临时存储
	tempAvailable[0][0] = Available[0][0];
	tempAvailable[0][1] = Available[0][1];
	tempAvailable[0][2] = Available[0][2];

	if (Algorithm_PCB(Available, readList) ==true) {
		//重置回readList；
		//重置剩余量：
		Available[0][0] = tempAvailable[0][0];
		Available[0][1] = tempAvailable[0][1];
		Available[0][2] = tempAvailable[0][2];
		readList = temp_ReadList;
		//如果第一次能有安全序列，那么有可能还有资源可以申请资源。
		Continue_Algorithm(readList);
	}
	else {
		cout << "一开始就没有安全序列！你还想有后续的申请？那是不可能的！" << endl;
	}
	return 0;
}
Alanmian
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
银行家算法（C++实现）
m0_58136789的博客
11-23 2万+
操作系统实验内容，银行家算法的实现，基于C++语言
操作系统银行家算法模拟实现（C语言版）
热门推荐
闭关修炼——暂退
05-23 8万+
目录 一、实验目的 二、实验内容 三、实验要点说明 银行家算法实例 程序结构 四、实验代码 五、实验运行结果 一、实验目的 通过编写一个模拟动态资源分配的银行家算法程序，进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念，并掌握避免死锁的具体实施方法。 二、实验内容 （1）模拟一个银行家算法： 设置数据结构 设计安全性算法 （2） 初始化时让系统拥有一定的资源 （3） 用键盘输入的方式申请资源 （4）如果预分配后，系统处于安全...
银行家算法
m0_66711291的博客
04-25 901
银行家算法是一个避免死锁的算法，用银行家放贷作为示例，银行家在放贷是需要评估放贷后是否还有能力为其他用户放贷，如果能做到则可以放贷给用户，否则则收回。在计算机中也是类似的操作，操作系统给进程分配资源时，需要评估分配完资源后整个系统是否还能够正常运行。整个算法由三部分组成：算法所用的数据结构，算法整体描述，安全性检测子算法。
银行家算法C++实现
weixin_69556696的博客
11-20 909
如果检验都通过则资源申请成功，如果资源申请不通过、则返回先前序列。请求序列request和available可获得序列的比较。请求序列request和need现需求序列的比较。若前面两道检验通过，则需要至少找出一个安全序列。有三道检验（在初始队列安全的情况下）
银行家算法——C++实现 [ 开源代码 + 详细解析 ]
Wang_Dou_Dou_的博客
12-31 1万+
关键词：运行结果图、银行家算法简介(Dijkstra在1965年提出)、安全状态、算法实质与思想、算法所需的相关数据结构、算法的设计思想、算法样例、完整代码 —— C++版本
银行家算法C++实现（源代码）
09-13
银行家算法（Banker's Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。
操作系统-银行家算法课设
最新发布
06-07
此系统需要注意的问题和可以完成的功能如下： （1）进程的已分配数量和需要的数量相加不能超过此类资源的总数、在进行输入时，每一项的Max和Allocation依次输入，中间用空格隔开。 （2）系统会自动输出Need矩阵，若...
操作系统银行家算法避免死锁
06-17
银行家算法避免死锁 VM软件 Linux系统 C语言 成功编译 成功运行 内附完整课设报告，代码，运行cpp 附有哲学家进餐简略一题 原课设要求：死锁避免 （1）请设计一个程序演示死锁避免算法（银行家算法）。 （2）要求该...
操作系统银行家算法C++源文件
05-28
银行家算法资源分配模拟器C++源文件，用于大学操作系统实验课代码的参考。
操作系统-银行家算法（c++）
01-08
操作系统--银行家算法（c++）
操作系统银行家算法.doc
11-13
操作系统银行家算法 操作系统银行家算法是一种资源分配算法，用于解决操作系统中的资源竞争问题。该算法通过检查系统的安全性和稳定性，确保系统不会陷入死锁或饥饿状态。 银行家算法的原理 银行家算法的核心思想...
C++ 银行家算法实现（手动矩阵输入）
11-24
主函数调用三个函数void init(输入)、bool safe(安全性算法)、void bank（银行家算法）.. 没有释放资源代码段 所以不能实现银行家算法的全部过程 定义如下 #include <iostream> using namespace std; #define MAXPROCESS 50 /*最大进程数*/ #define MAXRESOURCE 100 /*最大资源数*/ int AVAILABLE[MAXRESOURCE]; /*可用资源数组*/ int MAX[MAXPROCESS][MAXRESOURCE]; /*最大需求矩阵*/ int ALLOCATION[MAXPROCESS][MAXRESOURCE]; /*分配矩阵*/ int NEED[MAXPROCESS][MAXRESOURCE]; /*需求矩阵*/ int REQUEST[MAXPROCESS][MAXRESOURCE]; /*进程需要资源数*/ bool FINISH[MAXPROCESS]; /*系统是否有足够的资源分配*/ int p[MAXPROCESS]; /*记录序列*/ int m,n; /*m个进程,n个资源*/ void Init(); bool Safe(); void Bank();
操作系统实验四——银行家算法（C++实现）
qq_34245098的博客
04-17 1万+
描述 编程实现下题中“银行家算法”，要求程序运行时，根据不同的要求，给予是否分配资源的回答，如果可分配，输出安全序列，不可分配则输出拒绝理由。 代码 #include <cstdio> #include <cstring> #include <iostream> #include <algorithm> using namespace std; const int N = 12,M = 12; //最大进程数，最大资源种类 int n,m; //n个进
操作系统实验之银行家算法
freezesword的专栏
11-23 2959
smilesword.com 1． 实验目的和要求 银行家算法是避免死锁的一种重要方法，要求编写和调试一个简单的银行家算法程序。加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。 2． 实验内容 1．设计进程对各类资源最大申请表示及初值确定。 2．设定系统提供资源初始状况。 3．设定每次某个进程对各类资源的申请表示。 4．编制程序，依据银行家算法，决
C++实现银行家算法
maybeth的博客
05-23 845
银行家算法 申请者事先说明对各类资源的最大需求量。在进程活动期间动态申请某类资源时，由系统审查系统现有该类资源的数目是否能满足当前进程的最大需求量，如能满足就予以分配，否则拒绝。 银行家算法中的数据结构 (1) 可利用资源向量Available。这是一个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目，其初始值是系统中所配置的该类全部可用资源的数目，其数值随该类资源的分配和回收而动态地...
【OS笔记 29】处理死锁的四种方法——避免死锁（资源分配图算法与银行家算法）
qq_43722079的博客
09-11 6400
一、系统安全状态 系统处于安全状态时，就可避免死锁；处于不安全状态时，可能发生死锁。 1. 安全状态与不安全状态 所谓安全状态，是指系统此时能找到一个进程的序列<P1,P2,P3…Pn>，只要按照此顺序为其分配资源，就能使每个进程都能顺利完成。 ...
银行家算法C++代码实现
Carmelo_7的博客
11-10 6127
一、算法介绍 ​ 银行家算法（Banker’s Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。 ​ 多个进程动态地共享系统的资源可能会产生死锁现象。死锁的产生，必须同时满足四个条件，第一个是互斥条件，即一个资源每次只能由一个进程占用；第二个为请求和保持条件，即一个进程请求资源不能满足时，它必须等待，但它仍继续保持已得到的所有其它资源；第三个是不剥夺条
银行家算法c++
k5426244的博客
01-04 1705
假设在进程并发执行时进程i提出请求j类资源k个后， 表示为Requesti[j]=k,系统按下述步骤进行安全检查：1.如果Requesti≤Needi则继续以下检查， 否则显示需求申请超出最大需求值的错误。2. 如果Requesti≤Available则继续以下检查， 否则显示系统无足够资源， Pi阻塞等待。
操作系统——银行家算法（含源码实现C++）
qq_63055790的博客
01-14 1326
在多道程序系统中，多个进程的并发执行来改善系统的资源利用率，提高系统的吞吐量，但可能发生一种危险——死锁。所谓死锁(Deadlock)，是指多个进程在运行过程中因争夺资源而造成的一种僵局，当进程处于这种状态时，若无外力作用，他们都无法在向前推进。要预防死锁，有摒弃“请求和保持”条件，摒弃“不剥夺”条件，摒弃“循环等待”条件等方法。但是，在预防死锁的几种方法之中，都施加了较强的限制条件；而在避免死锁的方法中，所施加的限制条件较弱，有可能获得令人满意的系统性能。
计算机操作系统：银行家算法c++
12-20
下面是一个使用C++实现银行家算法的示例： ```cpp #include using namespace std; const int MAX_PROCESS = 10; const int MAX_RESOURCE = 10; int main() { int available[MAX_RESOURCE]; int maxDemand[MAX_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值