操作系统课程设计-银行家算法的模拟与实现

已于 2024-03-01 15:58:16 修改
阅读量1.1k 收藏 32
点赞数 10
分类专栏： 操作系统 文章标签： windows 算法
于 2024-01-17 23:36:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63306482/article/details/135662819
版权

目录

 

前言

1 实验题目

2 实验目的

3 实验内容

3.1 步骤

3.2 关键代码

3.2.1 预分配preAlloc函数

3.2.2 恢复资源recoverAlloc函数

3.2.3 分配资源Alloc函数

3.2.4 分配资源Alloc函数

4 实验结果与分析

5 代码

前言

         本实验为课设内容，博客内容为部分报告内容，仅为大家提供参考，请勿直接抄袭，另外，本次实验所用平台是dev c++5.11

1 实验题目

        实验六 银行家算法的模拟与实现

2 实验目的

        (1) 进一步了解进程的并发执行。

        (2) 加强对进程死锁的理解，理解安全状态与不安全状态的概念。

        (3) 掌握使用银行家算法避免死锁问题。

3 实验内容

3.1 步骤

        （1）初始化资源，给系统分配固定的资源。

        （2）通过键盘输入动态申请资源。

        （3）实现展示数据模块showData函数。

        （4）实现预分配模块preAlloc函数。

        （5）实现检测安全性模块check函数。

        （6）实现分配资源模块Alloc函数。

        （7）实现恢复资源模块recoverAlloc函数。

3.2 关键代码

3.2.1 预分配preAlloc函数

void preAlloc(int i){
	for(int j=0;j<N;j++){
		Allocation[i][j]=Allocation[i][j]+Request[j];
		Available[j]=Available[j]-Request[j];
		Need[i][j]=Need[i][j]-Request[j];
	}
}

3.2.2 恢复资源recoverAlloc函数

void recoverAlloc(int i){
	for(int j=0;j<N;j++){
		Allocation[i][j]=Allocation[i][j]-Request[j];
		Available[j]=Available[j]+Request[j];
		Need[i][j]=Need[i][j]+Request[j];
	}
}

3.2.3 分配资源Alloc函数

void Alloc(int i){
	for(int j=0;j<N;j++){
		Available[j]=Available[j]+Allocation[i][j];
		Allocation[i][j]=0;
		Need[i][j]=0;
	}
}

3.2.4 分配资源Alloc函数

int check(int k){
	int tempAvail[N]={0};
	int safe[M];
	int zero=0,index=0;
	int i,j,Nflag=0,Mflag=0,flag=1;
	memcpy(tempAvail,Available,sizeof(Available));
	for(j=0;j<N;j++){
		if(!Need[k][j])zero++;
	}
	if(zero==N){
		safe[index++]=k;
		Alloc(k);
		Mflag++;
		memcpy(tempAvail,Available,sizeof(Available));
	}
	for(i=0;i<M;i++){
		Nflag=0;
		zero=0;
		for(j=0;j<N;j++){
			if(Need[i][j]<=tempAvail[j])Nflag++;
			if(!Need[i][j])zero++;
		}
		if(Nflag==N&&zero!=N){
			safe[index++]=i;
			//cout<<i<<" ";
			Alloc(i);
			Mflag++;
			i=0;
			i--;
			memcpy(tempAvail,Available,sizeof(Available));
			//showData();
		}
	}
	if(Mflag==M){
		cout<<"资源申请成功！"<<endl;
		cout<<"存在安全序列："; 
		for(i=0;i<M;i++){
			cout<<"p"<<safe[i]<<" ";
		}
		return 1;
	}
	else return 0;
}

4 实验结果与分析

（1）申请的资源能够找到安全序列，当p1进程申请R0、R1和R2的数量分别为0、0、1时，结合需求矩阵和已分配矩阵，可以知道存在安全序列p1、p0、p2、p3，程序运行结果如下图所示：

图1.1 申请资源后存在安全序列

（2）当p0进程申请的R0资源数为3大于需求矩阵中其需求的R0资源数时，会提示申请不合理，需要重新选择，如下图所示：

图1.2 合理性检测

（3）当p0进程申请的R0资源数为1大于当前系统中剩余的R0资源数时，会提示申请不可能，需要重新选择，如下图所示：

图1.3 可能性检测

（4）申请的资源不能够找到安全序列，当p0进程申请R0、R1和R2的数量分别为0、0、1时，结合需求矩阵和已分配矩阵，可以知道如果分配资源，则不存在安全序列，程序运行结果如下图所示：

图1.4 申请资源后不存在安全序列

5 代码

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

#define M 4 //进程数 
#define N 3 //资源种类 

int Claim[M][N]={{3,2,2},{6,1,3},{3,1,4},{4,2,2}}; //进程最大需求资源声明矩阵 
int Allocation[M][N]={{1,0,0},{6,1,2},{2,1,1},{0,0,2}}; //进程已分配资源矩阵 
int Need[M][N]; //需求矩阵 
int Resource[N]={9,3,6}; //系统资源总数 
int Available[N]; //系统剩余资源 
int Request[N]; //请求的资源 

void showData(){
	cout<<"最大申明矩阵（Claim）："<<endl; 
	cout<<"    R0 R1 R2"<<endl;
	for(int i=0;i<M;i++){
		cout<<"p"<<i<<"："; 
		for(int j=0;j<N;j++){
			cout<<Claim[i][j]<<"  ";
		}
		cout<<endl;
	}
	cout<<"已分配矩阵（Allocation）："<<endl; 
	cout<<"    R0 R1 R2"<<endl;
	for(int i=0;i<M;i++){
		cout<<"p"<<i<<"："; 
		for(int j=0;j<N;j++){
			cout<<Allocation[i][j]<<"  ";
		}
		cout<<endl;
	}
	cout<<"需求矩阵（Need）："<<endl; 
	cout<<"    R0 R1 R2"<<endl;
	for(int i=0;i<M;i++){
		cout<<"p"<<i<<"："; 
		for(int j=0;j<N;j++){
			cout<<Need[i][j]<<"  ";
		}
		cout<<endl;
	}
	cout<<"系统资源总数（Resource）："<<endl; 
	cout<<"R0   R1   R2"<<endl;
	for(int i=0;i<N;i++){
		cout<<Resource[i]<<"    ";
	}
	cout<<endl<<"系统剩余资源（Available）："<<endl; 
	cout<<"R0   R1   R2"<<endl;
		for(int i=0;i<N;i++){
		cout<<Available[i]<<"    ";
	}
	cout<<endl;
}

void preAlloc(int i){
	for(int j=0;j<N;j++){
		Allocation[i][j]=Allocation[i][j]+Request[j];
		Available[j]=Available[j]-Request[j];
		Need[i][j]=Need[i][j]-Request[j];
	}
}

void recoverAlloc(int i){
	for(int j=0;j<N;j++){
		Allocation[i][j]=Allocation[i][j]-Request[j];
		Available[j]=Available[j]+Request[j];
		Need[i][j]=Need[i][j]+Request[j];
	}
}

void Alloc(int i){
	for(int j=0;j<N;j++){
		Available[j]=Available[j]+Allocation[i][j];
		Allocation[i][j]=0;
		Need[i][j]=0;
	}
}

int check(int k){
	int tempAvail[N]={0};
	int safe[M];
	int zero=0,index=0;
	int i,j,Nflag=0,Mflag=0,flag=1;
	memcpy(tempAvail,Available,sizeof(Available));
	for(j=0;j<N;j++){
		if(!Need[k][j])zero++;
	}
	if(zero==N){
		safe[index++]=k;
		Alloc(k);
		Mflag++;
		memcpy(tempAvail,Available,sizeof(Available));
	}
	for(i=0;i<M;i++){
		Nflag=0;
		zero=0;
		for(j=0;j<N;j++){
			if(Need[i][j]<=tempAvail[j])Nflag++;
			if(!Need[i][j])zero++;
		}
		if(Nflag==N&&zero!=N){
			safe[index++]=i;
			//cout<<i<<" ";
			Alloc(i);
			Mflag++;
			i=0;
			i--;
			memcpy(tempAvail,Available,sizeof(Available));
			//showData();
		}
	}
	if(Mflag==M){
		cout<<"资源申请成功！"<<endl;
		cout<<"存在安全序列："; 
		for(i=0;i<M;i++){
			cout<<"p"<<safe[i]<<" ";
		}
		return 1;
	}
	else return 0;
}

void bank(){
	char flag;
	int Rflag=0;
	int i=0,j=0;
	cout<<"是否进行资源申请，输入'y'继续，输入'n'退出："; 
	cin>>flag; 
	while(flag!='y'&&flag!='n'){
		cout<<"输入错误，请从新输入：";
		cin>>flag;
	} 
	while(flag=='y'){
		i=-1;
		cout<<"请输入申请资源的进程号p(0-"<<M-1<<")：p";
		cin>> i;
		while(i<0||i>M-1){
			cout<<"进程号错误请重新输入：p";
			cin>> i;
		}
		for(j=0;j<N;j++){
			cout<<"申请R"<<j<<"资源的个数：";
			cin>>Request[j];
			if(Request[j]>Need[i][j]){
				cout<<"申请不合理，进程p"<<i<<"申请的该资源与所分配的该资源数总和大于该资源的最大申明数，请重新选择！！！";
				Rflag=1;
				break;
			}else{
				if(Request[j]>Available[j]){
					cout<<"申请不可能，进程p"<<i<<"申请的该资源与大于系统该资源的剩余数，请重新选择！！！";
					Rflag=1;
					break;
				}else{
					Rflag=0;
				}
			}
		}
		if(!Rflag){
			preAlloc(i);
			if(check(i)){
				//Alloc();
				flag='n'; 
			}else{
				recoverAlloc(i);
				cout<<"资源分配后，不存在安全序列，出错，请重新选择！！！"<<endl;
				//cin>>flag; 
				cout<<"是否进行资源申请，输入'y'继续，输入'n'退出："; 
				cin>>flag; 
				while(flag!='y'&&flag!='n'){
					cout<<"输入错误，请从新输入：";
					cin>>flag; 
				} 
			}
		}else{
			cout<<endl<<"是否进行资源申请，输入'y'继续，输入'n'退出："; 
			while(flag!='y'&&flag!='n'){
				cout<<"输入错误，请从新输入：";
				cin>>flag; 
			} 
		} 
	}
}
int main(){
	memcpy(Available,Resource,sizeof(Resource));
	for(int i=0;i<M;i++) {
		for(int j=0;j<N;j++){
			Need[i][j]=Claim[i][j]-Allocation[i][j];
			Available[j]=Available[j]-Allocation[i][j];
		}
	}
	cout<<"----------银行家算法模拟---------"<<endl;
	showData();
	bank();
	return 0;
}

望525
关注
  • 10
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
银行家算法C++实现
weixin_44735393的博客
01-17 1219
一、实验目的 为了了解系统的资源分配情况，假定系统的任何一种资源在任意时刻只能被一个进程使用。任何进程已经占用的资源只能有进程自己释放，而不能由其他进程抢占。当进程申请的的资源不能满足时，必须等待。因此，只要资源分配算法能保证进程的资源请求，且不出现循环等待，则系统不会出现死锁。 要求编写系统进行资源调度的程序即银行家算法，有效的避免死锁的产生。 二、实验内容 （1）设计3-4个并发进程，共享系统...
操作系统课程设计--银行家算法的模拟实现
一个简单的博客
01-11 7392
发一些大三操作系统的实验代码吸引阅读量吧，当时做实验的时候看见网上很多人写的代码并不好，而且很多人都有错误的地方。如果好的话希望能点赞关注。 本篇文章选自课程设计报告的部分，所以相比前两篇实验详细很多，我尽量贴一些重要的部分出来 在多道程序系统中，多个进程在运行中对于资源的争夺而造成了一种僵局—死锁，若无外力作用，则这些进程均无法向前推进。如此，寻求避免死锁的方法就显得尤为重要。死锁产生的原因
操作系统原理与实验——实验六银行家算法模拟与实现
m0_62806440的博客
03-12 820
1、该算法运用了大量的分支结构，增强了我的逻辑2、结构体不能当数组使用3、在实验过程中要多想，在写程序时，我一直找不到安全算法的循环条件，后来想到用计数来做循环条件4、当然对函数的调用不是很多，导致main函数比较庞大5、复习了continue的用法6、还要多加练习，优化该算法。
操作系统课程设计银行家算法的模拟实现.doc
12-23
操作系统课程设计银行家算法的模拟实现
操作系统 实验六 银行家算法的模拟与实现
最新发布
2303_77394523的博客
06-21 507
保证得到的资源的进程能在有限的时间内归还资源，以供其它进程使用资源。银行家算法顾名思义是来源于银行的借贷业务，一定数量的本金要满足多个客户的借贷周转，）执行安全性算法，若该新状态是安全的，则分配完成；若新状态是不安全的，则恢复原状。） 如果试探分配后系统处于不安全状态，则提示不能满足请求，恢复原状态并阻塞该进程。） 如果试探分配后系统处于安全状态，则修改系统的资源分配情况，正式分配资源；：能找到安全序列的状态称为安全状态，安全状态不会导致死锁。加强对进程死锁的理解，理解安全状态与不安全状态的概念。
银行家算法
weixin_52457534的博客
05-19 686
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决.
实验六 银行家算法的模拟与实现
double_warmth的博客
12-21 1603
银行家算法
银行家算法的模拟与实现
热门推荐
我的书包哪里去了
06-11 3万+
一、实验目的(1) 进一步了解进程的并发执行。(2) 加强对进程死锁的理解，理解安全状态与不安全状态的概念。(3) 掌握使用银行家算法避免死锁问题。二、总体设计2.1实验基本知识及原理（1）基本概念死锁：多个进程在执行过程中，因为竞争资源会造成相互等待的局面。如果没有外力作用，这些进程将永远无法向前推进。此时称系统处于死锁状态或者系统产生了死锁。安全序列：...
操作系统课程设计银行家算法
wangiijing的博客
05-19 4860
#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]
计算机操作系统课程设计银行家算法的设计与实现
05-16
计算机操作系统课程设计银行家算法的设计与实现 计算机操作系统课程设计报告题目中的银行家算法的设计与实现是本次课程设计的主要内容。该设计的目的是模拟实现资源分配，避免死锁的发生。银行家算法是避免死锁的一...
操作系统课程设计银行家算法（附详细报告）
07-14
设计一个n个并发进程共享m个系统资源的程序以实现银行家算法。要求： 1） 简单的选择界面； 2） 能显示当前系统资源的占用和剩余情况。 3） 为进程分配资源，如果进程要求的资源大于系统剩余的资源，不与分配并且...
操作系统课程设计银行家算法模拟实现.pdf
02-20
"操作系统课程设计银行家算法模拟实现" 本课程设计的主要目的是通过模拟银行家算法来防止死锁的出现，深入理解操作系统的原理和实现方法，加强学生的动手能力。银行家算法是操作系统中的一种资源分配算法，用于避免...
操作系统课程设计银行家算法模拟实现.docx
02-20
操作系统课程设计中的银行家算法是一种用于预防死锁的策略，主要应用于多道程序系统中，以确保系统的资源分配不会导致进程间的死锁状态。银行家算法的核心思想是通过预先预测和控制资源分配，来避免系统进入不安全...
死锁概念及产生原理
ych_ych918的博客
09-20 1638
欢迎使用Markdown编辑器 死锁概念及产生原理     概念： 多个并发进程因争夺系统资源而产生相互等待的现象。     原理： 当一组进程中的每个进程都在等待某个事件发生，而只有这组进程中的其他进程才能触发该事件，这就称这组进程发生了死锁。     本质原因：         1
操作系统——银行家算法的模拟与实现
CSH__的博客
06-25 2658
操作系统课设：实验五
C++实现操作系统银行家算法的模拟实现
SLxiaoyun的博客
05-29 4137
该实验具体要求为： （1）设计3-4个并发进程，共享系统的10个同类不可抢占的资源。各进程动态地进行资源的申请和释放。 （2）用银行家算法设计一个资源分配程序，运行这两个程序，观察系统运行情况，并对系统运行的每一步情况进行显示。 具体做法： 1.首先建立一个数组类，包含四个元素（即代表四个进程），在类中定义四个私有变量need,maxrequire,already,flag分别代表进程的资源仍需申请量，资源需求总量，已占资源量 和 能否执行完标志（其实设置为公有变量比较省事，因为可以直接访问修改它的值，不需
计算机操作系统实验：银行家算法模拟
m0_72471315的博客
05-04 3156
本文是计算机操作系统实验的一部分，主要介绍了银行家算法的原理和实现。银行家算法是一种用于解决多个进程对多种资源的竞争和分配的算法，它可以避免死锁和资源浪费的情况。银行家算法的思想是模拟银行家对贷款申请的处理过程，即在保证系统安全性的前提下，尽可能满足每个进程的资源需求。本文将通过C语言编程，实现一个简单的银行家算法模拟程序，并展示其运行结果和分析。本文是对计算机操作系统实验中银行家算法模拟的总结。银行家算法是一种用于避免死锁和资源浪费的动态分配算法，它模拟了银行家在贷款时的策略。
Banker-银行家算法模拟实现
npu_nazi的博客
03-21 3391
银行家算法设计与实现 实验内容 假定有多个进程对多种资源进行请求，设计银行家算法的数据结构和程序结构，判定是否存在资源分配的安全序列。使用C语言或Python语言编写程序实现这个算法并进行测试。 主要实现方法和代码介绍 编写进程类, 用来存储max, allocation,need等需要的向量. 分别编写第一次,第二次输入 和输出的类 .用来格式化的输入数据和输出数据. 编写 check方法,检测进程p是否可以进行资源分配, 具体思想就是 :检查need向量小于max-allocation; 检查need
【操作系统】银行家算法的实现
只识闲人不识君博客
06-25 2977
银行家算法对应实验一、银行家算法概念二、实验环境三、实验题目四、实验步骤五、实验代码六、实验结果 一、银行家算法概念 银行家算法（Banker’s Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。 安全序列：如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。安全状态一定是没有死锁发生。 不安全状序列：不存在一个安全序列。不安
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值