【C++】操作系统之实验二银行家算法

admin 管理员组

文章数量: 887021

文章目录

• 一、实验内容
• 二、实验原理
• • 1、什么是系统的安全状态和不安全状态？
  • 2、银行家算法
  • 3、操作系统按照银行家制定的规则设计的银行家算法为：
• 三、实验要求
• • 1、画出银行家算法流程图；
  • 2、对算法所用的数据结构进行说明；
  • 3、测试数据随机产生。不可手工输入；
  • 4、 编写程序并调试；
  • 5、 多次测试程序，截屏输出实验结果；
• 四、思考题
• • 1、如何设计程序的输入模块才能满足实验要求，请举例说明；
  • 2、银行家算法在实现过程中必须注意哪些资源分配细节才能避免死锁？

一、实验内容

根据银行家算法的基本思想，编写和调试一个实现动态资源分配的模拟程序，并能够有效避免死锁的发生。

二、实验原理

进程申请资源时，系统通过一定的算法判断本次申请是否不可能产生死锁（处于安全状态）。若可能产生死锁（处于不安全状态），则暂不进行本次资源分配，以避免死锁。算法有著名的银行家算法。

1、什么是系统的安全状态和不安全状态？

所谓安全状态，是指如果系统中存在某种进程序列＜P1，P2，…，Pn＞，系统按该序列为每个进程分配其所需要的资源，直至最大需求，则最终能使每个进程都可顺利完成，称该进程序列＜P1，P2，…，Pn，＞为安全序列。
如果不存在这样的安全序列，则称系统处于不安全状态。

2、银行家算法

把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。
为保证资金的安全，银行家规定:
(1) 当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客;
(2) 顾客可以分期贷款，但贷款的总数不能超过最大需求量;
(3) 当银行家现有的资金不能满足顾客尚需的贷款数额时,对顾客的贷款可推迟支付,但总能使顾客在有限的时间里得到贷款;
(4) 当顾客得到所需的全部资金后,一定能在有限的时间里归还所有的资金。

3、操作系统按照银行家制定的规则设计的银行家算法为：

（1）进程首次申请资源的分配：如果系统现存资源可以满足该进程的最大需求量，则按当前的申请量分配资源，否则推迟分配。
（2）进程在执行中继续申请资源的分配：若该进程已占用的资源与本次申请的资源之和不超过对资源的最大需求量，且现存资源能满足该进程尚需的最大资源量，则按当前申请量分配资源，否则推迟分配。
（3）至少一个进程能完成：在任何时刻保证至少有一个进程能得到所需的全部资源而执行到结束。
银行家算法通过动态地检测系统中资源分配情况和进程对资源的需求情况来决定如何分配资源，并能在确保系统处于安全状态时才把资源分配给申请者，从而避免系统发生死锁。

三、实验要求

1、画出银行家算法流程图；

2、对算法所用的数据结构进行说明；

（1）进程类，内涵资源目前需求数目、每个资源最大需求数目以及该进程是否已释放标记。用来创建进程，管理资源。

struct source
{
	int sour_need_num[10];	//每个进程的目前资源需求数,最多允许十种不同资源类型
	int sour_max_num[10];	//每个进程的最大资源需求数
	int release = 0;			//是否该进程已释放
};

（2）定义进程总数，可修改。

#define pronum 5//进程总数

（3）sy定义表示系统现有资源数目，用来跟进程内需求数目作比较以分配资源。

int sy[10];	//选择手动or随机，系统内现有资源数目

（4）进程队列，用来存储各进程的相应数据。

source s[pronum];		//进程队列

（5）分配资源类总数

int sour_class_num = (rand() % 5) + 1;//分配资源类总数

（6）用来记录开始时间和结束时间

clock_t startTime, endTime;

3、测试数据随机产生。不可手工输入；

4、 编写程序并调试；

// 银行家算法.c
#include<iostream>
#include<stdio.h>
#include<time.h>
#include<stdlib.h>
using namespace std;
#define pronum 5//进程总数
int  sour_class_num; //资源类总数
//定义资源结构
struct source
{
	int sour_need_num[10];				//每个进程的目前资源需求数,最多允许十种不同资源类型
	int sour_max_num[10];				//每个进程的最大资源需求数
	int release = 0;					//是否该进程已释放
	
};
/*每个资源总数，每个进程的最大资源需求数、
已分配资源数，系统当前资源数等数据要随机生成；*/
//初始化资源分配
void init_all_souce(int *s,int num=10)//系统当前资源数
{
	srand((int)time(0));
	for (int i = 0; i < sour_class_num; i++)
	{
		// 随机设定每个类的资源数目
		s[i] = rand() % num;
	}
}

void init_source(source *s,int num=15)//各进程资源
{
	srand((int)time(0));
	for(int i = 0;i<pronum;i++)
		for (int j = 0; j < sour_class_num; j++)
		{
			s[i].sour_max_num[j] = rand() % (num)+1;//每个进程的最大资源需求数
			s[i].sour_need_num[j] = (rand() % s[i].sour_max_num[j]) + 1;//每个进程的目前资源需求数
		}
}

void Output(source *s,int *sy)//输出查阅信息
{
	printf("进程名\t\t");
	for (int i = 1; i <= sour_class_num; i++)
	{
		printf("r%d\t", i);
	}
	printf("\n系统\t\t");
	for (int i = 0; i < sour_class_num; i++)
	{
		printf("%d\t", sy[i]);
	}
	for (int i = 0; i < pronum; i++)
	{
		printf("\n进程%d最大需求\t", i + 1);
		for (int j = 0; j < sour_class_num; j++)
		{
			printf("%d\t", s[i].sour_max_num[j]);
		}
		printf("\n进程%d目前需求\t", i + 1);
		for (int j = 0; j < sour_class_num; j++)
		{
			printf("%d\t", s[i].sour_need_num[j]);
		}
	}
	printf("\n");
}

int Banker(source *s,int *sy)//银行家算法
{
	for (int i = 0; i < pronum; i++)
	{
		int temp = 0;
		if (s[i].release)//如果这个进程已经被释放，换下一个进程
			continue;
		for (int j = 0; j < sour_class_num; j++)
		{//如果资源i的需求数目在系统可分配范围内，temp++
			if (s[i].sour_need_num[j] <= sy[j])
				temp++;
		}
		if (temp == sour_class_num)//这个资源满足
		{
			s[i].release = 1;//标记已释放
			for (int j = 0; j < sour_class_num; j++)
			{
				sy[j] -= s[i].sour_need_num[j];//系统分配资源给当前进程
				sy[j] += s[i].sour_max_num[j];//当前进程把资源还给系统
				s[i].sour_need_num[j] = 0;//需求归0
			}
			printf("进程%d能被满足需求\n\n目前系统未分配资源情况\n", i + 1);
			Output(s, sy);
			return 0;
		}
		else
		{
			printf("\n进程%d不能被满足需求\n",i+1);
		}
	}
	return 1;
}

int main()
{
	// 手动输入或随机选择
	srand((int)time(0));
	int sy[10];	//选择手动or随机，系统内现有资源数目
	source s[pronum];	//进程队列
	clock_t startTime, endTime;
	// 随机生成数据
	sour_class_num = (rand() % 5) + 1;//分配资源类总数
	init_all_souce(sy);//初始化系统资源
	init_source(s);//初始化进程资源
	// 赋值结束
	printf("赋值结束\n");
	Output(s, sy);
	// 银行家算法
	startTime = clock();
	for (int i = 0; i < pronum; i++)
	{
		if (Banker(s, sy))
		{
			endTime = clock();//计时结束
			printf("\n系统处于不安全状态\n");
			printf("程序的运行时间：%4fs\n", (double)(endTime - startTime) / CLOCKS_PER_SEC);
			return 0;
		}
	}
	endTime = clock();//计时结束
	printf("\n系统处于安全状态\n");
	printf("程序的运行时间：%f s\n", (double)(endTime - startTime) / CLOCKS_PER_SEC);
}

5、 多次测试程序，截屏输出实验结果；

结果一：（不死锁）

结果二：（死锁）

四、思考题

1、如何设计程序的输入模块才能满足实验要求，请举例说明；

（1）由于我们需要进行进程数和运行时间、运行数及时间/进程数的比对，因而我们需要控制程序可输入进程数。
（2）由于资源类数目不同对运行时间造成的影响较大，因此在进行实验比对时，不能放任资源类数目随机为任意数字，而是需要固定一个数据；除此以外的情况可以控制资源类数目为随机数。
（3）如每个进程的最大资源需求数、每个进程的目前资源需求数、系统当前资源数等数据要随机生成这类数据可以设置为一定范围内的随机数，每个进程的目前资源需求数也为随机数，但是得控制它的数据小于等于最大需求数目。
（4）进程的已分配资源数由最大资源需求数-目前资源需求数计算得出。

2、银行家算法在实现过程中必须注意哪些资源分配细节才能避免死锁？

检测已有资源数目是否大于等于进程目前资源需求数，若是，则分配资源给进程，同时可以回收进程释放的资源；反之推迟分配，检测已有资源数目是否大于等于下一个进程的进程目前资源需求数。

本文标签： 银行家 算法 操作系统