使用C++实现银行家算法避免进程死锁

已于 2022-12-22 20:38:18 修改
阅读量1.4k 收藏 22
点赞数 8
分类专栏： # 操作系统基础 文章标签： c语言 c++ 操作系统 银行家算法
于 2021-12-27 11:29:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48560325/article/details/122168216
版权

**最近事比较多 直接按书上来 **
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
.h

#pragma once
#include<iostream>
using namespace std;
void Dis_char(int i, char ch);
void Init();//初始化矩阵
void Display();//显示
void Display_2();
void Display_Security();//显示安全序列
void Require();//请求资源进程
int Banker();//银行家算法实现

.cpp

#include"Banker.h"
#define MAX_SOURCE 6 //可打印的最大资源数
#define MAX_ROW 6//列最多为6
#define MAX_LINE 4//行最多为4
#define STATE 4 //表格中的四列
int Max[MAX_ROW][MAX_LINE] = { 0 };//最大需求矩阵
int Allocation[MAX_ROW][MAX_LINE] = { 0 };//分配矩阵
int Need[MAX_ROW][MAX_LINE] = { 0 };//需求矩阵
int Available[MAX_LINE] = { 0 };//可利用资源向量
int Flag[MAX_ROW] = {1,1,1,1,1,1};//标志
int Security[MAX_ROW] = {0,1,2,3,4,5};//安全序列数组
int EXE[MAX_LINE] = { 0 };//中间转换可利用资源
int Require_num[MAX_LINE] = { 0 };//亲求资源
int Work[MAX_ROW][MAX_LINE] = { 0 };//系统可提供给进程继续运行所需各类资源
int Work_Allocation[MAX_ROW][MAX_LINE] = {0};
int PcbNum, Source;//进程数   资源数
void Dis_char(int i, char ch)
{
	while (i--)
	{
		cout << ch;
	}
}
void Init()//初始化
{
	int i, j;
	cout << "输入进程的个数：";
	cin >> PcbNum;
	cout << "输入资源的种类：";
	cin >> Source;
	cout << "输入系统剩余资源(Available):";
	for (i = 0; i < Source; i++)
	{
		cin >> Available[i];
	}
	cout << endl;

	cout << "输入Allocation矩阵" << endl;
	for (i = 0; i < PcbNum; i++)
	{
		for (j = 0; j < Source; j++)
		{
			cin >> Allocation[i][j];
		}
	}
	cout << endl;

	cout << "输入Need矩阵" << endl;
	for (i = 0; i < PcbNum; i++)
	{
		for (j = 0; j < Source; j++)
		{
			cin >> Need[i][j];
		}
	}
	for (i = 0; i < PcbNum; i++)
	{
		for (j = 0; j < Source; j++)
		{
			Max[i][j] = Allocation[i][j] + Need[i][j];
		}
	}
	for (i = 0; i < Source; i++)
	{
		EXE[i] = Available[i];
		Work[0][i] = Available[i];
	}
	cout << "\n初始化完毕,初始化列表为：\n\n";
	Display();
	cout << "正在检测初始系统是否安全.......\n";
	int security = Banker();
	if (security == 1)
	{
		printf("该状态为安全状态");
	}
	else
	{
		printf("该状态不是安全状态，请检查数据是否正确");
	}
	cout << endl;
	cout << "安全序列为：" << endl;
	Display_Security();
	Display(); 
}
void Display()
{
	char Name[] = "ABCDEFGH";
	int n = PcbNum;//进程数
	int m = Source;//资源数
	int i, j, tmp;

	//1.打印表头
	printf("|—————————————————————————————————————————-|\n");
	printf("%-8s%-19s%-19s%-19s%-20s", "|进\\资源", "|       Max        ", "|    Allocation    ", "|       Need       ", "|     Available    |\n");
	printf("|   \\情 |—————————|—————————|—————————|—————————|\n");
	printf("|程  \\况");
	for (i = 0; i < STATE; i++)
	{
		cout << "|";
		for (j = 0; j < m; j++)
		{
			printf(" %c ", Name[j]);
		}
		tmp = MAX_SOURCE - m;//超出的用空格弥补
		Dis_char(tmp * 3, ' ');
	}
	cout << "|\n";
	printf("|-------|—————————|—————————|—————————|—————————|\n");
	//2.打印每一行
	for (i = 0; i < n; i++)
	{
		printf("|  P%-2d  ", Security[i]);
		for (j = 0; j < m; j++)//Max数据
		{
			cout << "|";
			for (j = 0; j < m; j++)
			{
				printf(" %d ", Max[Security[i]][j]);
			}
			tmp = MAX_SOURCE - m;//超出的用空格弥补
			Dis_char(tmp * 3, ' ');
		}
		for (j = 0; j < m; j++)//Allcoation数据
		{
			cout << "|";
			for (j = 0; j < m; j++)
			{
				printf(" %d ", Allocation[Security[i]][j]);
			}
			tmp = MAX_SOURCE - m;//超出的用空格弥补
			Dis_char(tmp * 3, ' ');
		}
		for (j = 0; j < m; j++)//Need数据
		{
			cout << "|";
			for (j = 0; j < m; j++)
			{
				printf(" %d ", Need[Security[i]][j]);
			}
			tmp = MAX_SOURCE - m;//超出的用空格弥补
			Dis_char(tmp * 3, ' ');
		}
		cout << "|";
		for (j = 0; j < m; j++)//Available数据
		{
			printf(" %d ", Available[j]);
		}
		tmp = MAX_SOURCE - m;//超出的用空格弥补
		Dis_char(tmp * 3, ' ');
		cout << "|\n";
		printf("|-------|—————————|—————————|—————————|—————————|\n");
	}
}
void Display_2()
{
	char Name[] = "ABCDEFGH";
	int n = PcbNum;//进程数
	int m = Source;//资源数
	int i, j, tmp;
	printf("|—————————————————————————————————————————-|\n");
	printf("%-8s%-19s%-19s%-19s%-20s", "|进\\资源", "|       Work      ", "|      Need     ", "|   Allocation    ", "|  Work+Allocation |\n");
	printf("|   \\情 |—————————|—————————|—————————|—————————|\n");
	printf("|程  \\况");
	for (i = 0; i < STATE; i++)
	{
		cout << "|";
		for (j = 0; j < m; j++)
		{
			printf(" %c ", Name[j]);
		}
		tmp = MAX_SOURCE - m;//超出的用空格弥补
		Dis_char(tmp * 3, ' ');
	}
	cout << "|\n";
	printf("|-------|—————————|—————————|—————————|—————————|\n");
	for (i = 0; i < n; i++)
	{
		printf("|  P%-2d  ", Security[i]);
		for (j = 0; j < m; j++)//Max数据
		{
			cout << "|";
			for (j = 0; j < m; j++)
			{
				printf(" %d ", Work[Security[i]][j]);
			}
			tmp = MAX_SOURCE - m;//超出的用空格弥补
			Dis_char(tmp * 3, ' ');
		}
		for (j = 0; j < m; j++)
		{
			cout << "|";
			for (j = 0; j < m; j++)
			{
				printf(" %d ", Need[Security[i]][j]);
			}
			tmp = MAX_SOURCE - m;//超出的用空格弥补
			Dis_char(tmp * 3, ' ');
		}
		for (j = 0; j < m; j++)
		{
			cout << "|";
			for (j = 0; j < m; j++)
			{
				printf(" %d ", Allocation[Security[i]][j]);
			}
			tmp = MAX_SOURCE - m;//超出的用空格弥补
			Dis_char(tmp * 3, ' ');
		}
		for (j = 0; j < m; j++)
		{
			cout << "|";
			for (j = 0; j < m; j++)
			{
				printf(" %d ", Work_Allocation[Security[i]][j]);
			}
			tmp = MAX_SOURCE - m;//超出的用空格弥补
			Dis_char(tmp * 3, ' ');
		}
		cout << "|";
		
		if (Flag[i] == 0)
		{
			printf("   true  ");
		}
		else
		{
			printf("  false  ");
		}
		
		cout << "|\n";
		printf("|-------|—————————|—————————|—————————|—————————|\n");
	}

}
void Display_Security()
{
	int arr[MAX_LINE] = { 0 };
	for (int i = 0; i < Source; i++)
	{
		arr[i] = Available[i];
	}
	for (int i = 0; i < PcbNum; i++)
	{
		cout << "P"<<Security[i] << "--->";
	}
	cout << endl;
	for (int i = 0; i < PcbNum; i++)
	{
		for (int j = 0; j < Source; j++)
		{
			Work[Security[i]][j] = arr[j];
			Work_Allocation[Security[i]][j] = Work[Security[i]][j] + Allocation[Security[i]][j];
			arr[j] = Work_Allocation[Security[i]][j];
		}
	}
}
int Security_Judge(int pid)
{
	int cur = 0;//判断是否小于need
	int ptr = 0;//判断是否小于Available
	while (cur != Source)
	{
		if (Require_num[cur] <= Need[pid][cur])
		{
			cur++;
		}
		else
		{
			return 1;
			break;
		}
	}
	while (ptr != Source)
	{
		if (Require_num[ptr]<=Available[ptr])
		{
			ptr++;
		}
		else
		{
			return 2;
			break;
		}
	}
	return 0;
}
void Require()
{
	int Pid, tmp;
	cout << "输入要想系统请求资源的进程Id：";
	cin >> Pid;
	cout << "输入要想向系统请求资源的大小：";
	for (int i = 0; i < Source; i++)
	{
		cin >> Require_num[i];
	}
	tmp = Security_Judge(Pid);
	if (tmp == 1)
	{
		cout << "\n请求出错！此进程请求资源超过它宣布的最大需求！！！\n";
		cout << "当前时刻资源分配表\n"; 
		Display();

	}
	if (tmp == 2)
	{
		cout<<"\n请求出错！此请求所需资源超过系统资源，P" << Pid << "进程等待！！！\n"; 
		cout << "当前时刻资源分配表\n"; Display(); 
	}
	if (tmp == 0)
	{
		cout << "请求成功正在检测系统是否安全！！！" << endl;
		for (int i = 0; i < Source; i++)
		{
			Available[i] = Available[i] - Require_num[i];
			Need[Pid][i] = Need[Pid][i] - Require_num[i];
			Allocation[Pid][i] += Require_num[i];
			Max[Pid][i] = Allocation[Pid][i] + Need[Pid][i];
		}
		for (int i = 0; i < MAX_ROW; i++)
		{
			Flag[i] = 1;
		}
		int security = Banker();
		if (security == 1)
		{
			cout << "该状态为安全状态！安全序列为：" << endl;
			Display_Security();
			Display();

		}
		if (security == -1)
		{
			cout << "该状态不是安全状态，请检查数据是否正确" << endl;
			Display();
		}
	}
}
int Banker()
{
	int key = 0;
	int tmp = PcbNum;
	while (tmp != 0)
	{
		int ptr = 0;
		while (ptr !=PcbNum)
		{
			if (Flag[ptr] == 0)
			{
				ptr++;
			}
			else
			{
				int i = 0;
				while (i != Source)
				{
					if (Need[ptr][i] <= EXE[i])
					{
						i++;
					}
					else
					{
						break;
					}
				}
				if (i == Source)
				{
					Flag[ptr] = 0;
					Security[key] = ptr;
					key++;
					for (int i = 0; i < Source; i++)
					{
						EXE[i] += Allocation[ptr][i];
					}
					tmp--;
					break;
				}
				else
				{
					ptr++;

				}
				
			}
		}
		if (ptr == PcbNum && Flag[ptr - 1] == 1)
		{
			return -1;
			break;
		}

	}
	return 1;
}

.cpp

#include"Banker.h"
int main()
{
	int choose;
	while (1)
	{
		cout << "           银行家算法：" << endl << endl;
		cout << "*****  1 - 初始化各矩阵        *****" << endl;
		cout << "*****  2 - 进程提出请求        *****" << endl;
		cout << "*****  3 - 显示各进程资源情况  *****" << endl;
		cout << "*****  0 - 结束                *****" << endl << endl;
		cout << "输入你的选择 ： ";
		cin >> choose;
		switch (choose)
		{
		case 0:exit(0); break;
		case 1:Init(); break;
		case 2:Require(); break;
		case 3:Display_2(); break;
		default:cout << "请输入正确的序号：" << endl;
		}
	}
	return 0;
}

结果
在这里插入图片描述

佬酒
关注
专栏目录
利用银行家算法避免死锁（C++实现）
qq_40159978的博客
06-05 2152
算法思想： 代码： #include<iostream> #include<string> using namespace std; #define numberOfProcess 5 #define numberOfReSource 3 int *available=new int[numberOfReSource]; int *work...
银行家算法——死锁避免（C++代码实现）
adobemomo的博客
04-21 4402
安全状态如果存在一个安全序列，那么系统处于安全状态。对于进程顺序&lt;P1,P2,...,Pn&gt;，有如下            Pi-need &lt;= Pj-hold + All-available则这一顺序为安全序列。可以保证所有进程按此顺序执行后，资源分配不会发生死锁。银行家算法·数据结构1）可利用资源向量Available是个含有m个元素的数组，其中的每一个元素代表一类可利用的资...
银行家算法
中文过六级再取名的博客
11-21 316
银行家算法 代码如下： #include<stdio.h> #define resourceNum 3 #define processNum 5 //系统可用（剩余）资源 int available[resourceNum]={3,3,2}; //进程的最大需求 int maxRequest[processNum][resourceNum]={{7,5,3},{3,2,2},{9,...
一文搞懂银行家算法
最新发布
m0_62056231的博客
07-17 4297
死锁是指在计算机系统中，多个进程或线程因竞争资源或互相等待而陷入的一种永久阻塞的状态。互斥条件：某些资源在同一时间只能被一个进程使用。如果其他进程请求该资源，则必须等待。占有且等待条件：一个进程已经持有至少一个资源，但又请求新的资源，而新的资源正被其他进程持有，因此进程必须等待。不剥夺条件：资源不能被强行从一个进程中剥夺，必须由持有它的进程主动释放。循环等待条件：存在一个进程链，使得每个进程都在等待链中的下一个进程所持有的资源，形成一个环形等待链。
操作系统-死锁避免：银行家算法(C++实现)
yifunxxx的博客
04-09 985
#include<iostream> #include<string> using namespace std; //定义资源的最大数量 #define r_max 99 //定义全局变量 int num_r,i,j,order[r_max],Max[r_max][r_max],Allocation[r_max][r_max],Need[r_max][r_max],wor...
c语言实现银行家算法避免死锁,C实现银行家算法（避免死锁）
weixin_35801556的博客
05-24 844
#include#include#include#define SourceType 3#define ProcessNum 5//第SourceNum类可用资源数：typedefstructAvailable{int Available[SourceType];}Ava;//进程ProcessNum对资源SourceNum类资源的最大需求：typedefstructMax{int Max[Pro...
操作系统银行家算法避免死锁
06-17
银行家算法避免死锁 VM软件 Linux系统 C语言 成功编译 成功运行 内附完整课设报告，代码，运行cpp 附有哲学家进餐简略一题 原课设要求：死锁避免 （1）请设计一个程序演示死锁避免算法（银行家算法）。 （2）要求该...
C++实现OS的银行家算法，避免死锁。比较初级
12-08
"银行家算法的 C++ 实现" 银行家算法（Banker's algorithm）是一种避免死锁的算法，它是操作系统中的一种资源分配算法，目的是为了避免死锁和饥饿的发生。该算法的主要思想是通过判断当前系统的状态是否安全，避免...
基于 C++实现的避免死锁的银行家算法
05-09
《基于C++实现的银行家算法：有效避免死锁的关键技术》 银行家算法是解决系统资源分配中死锁问题的一种经典策略，由艾兹格·迪杰斯特拉在1965年提出。该算法的主要目标是确保系统的安全性，即在任何情况下，系统都...
银行家算法避免进程死锁 可调式文件
05-27
银行家算法避免进程死锁 可调式文件cpp银行家算法避免进程死锁 可调式文件cpp
银行家算法避免死锁源代码(C#篇)
08-07
本文档是使用C#编写的银行家算法避免死锁的程序设计。里面包含数组初始化，利用递归判断输入整数，输出安全序列等函数，希望对大家有帮助。如有错误，请多多指教~
银行家算法避免死锁C语言代码实现
01-18
银行家算法的实现，当输入每类资源的MAX和Allocation，计算是否存在安全序列
操作系统实验三 预防进程死锁的银行家算法
02-03
操作系统实验三 预防进程死锁的银行家算法（内含源代码和详细实验报告），详细介绍：http://blog.csdn.net/xunciy/article/details/79239096
模拟实现银行家算法实现死锁避免
01-12
银行家算法是避免死锁的一种重要方法，本实验要求用级语言编写和调试一个简单的银行家算法程序。
银行家算法避免死锁
11-30
银行家算法避免死锁问题的C++程序，初始状态从文件中读入，本程序是对《计算机操作系统》第四版汤小凤一书中所描述的银行家算法实验
实验二 预防进程死锁的银行家算法
weixin_46783643的博客
03-15 198
实验二 预防进程死锁的银行家算法
mysql 银行家算法_避免死锁：银行家算法代码解析
weixin_33740988的博客
02-02 170
原题：实验四文件系统-代码阅读并调试实验1.阅读下面源代码，写出程序功能。2.阅读代码，分析代码中算法并说明。3.调试并运行代码，写出结果。答题内容略，本文仅逐段解析实验代码，以及在文章最后附上算法流程图。头文件和自定义变量，特别强调，本程序只支持资源种类数为3种以下的情况。#define _CRT_SECURE_NO_WARNINGS 1#include#includeint Available...
银行家算法避免死锁C/C++
g15827636417的博客
12-14 6079
一、数据结构的定义 1）可利用资源向量Available 是个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目。如果Available[j]=K，则表示系统中现有Rj类资源K个。2）最大需求矩阵Max 这是一个n×m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。如果Max[i,j]=K，则表示进程i需要Rj类资源的最大数目为K。3）分配矩阵Allocation
C++实现银行家算法避免死锁
实验目标包括深入理解死锁避免机制，掌握银行家算法的原理，并编写C++程序来模拟该算法，同时验证计算结果与手动计算的一致性。实验原理涉及安全状态的定义，即系统能够按照特定顺序为每个进程分配资源，使它们能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值