银行家算法

最新推荐文章于 2024-09-10 08:28:20 发布

=, =

最新推荐文章于 2024-09-10 08:28:20 发布

阅读量1.6k

点赞数 43

文章标签： c++ vscode 数据结构算法

本文链接：https://blog.csdn.net/qq_62143596/article/details/134944289

版权

一、实验目的

用高级语言编写和调试一个银行家算法程序，并可以利用银行家算法模拟分配资源以及进行安全性检查。加深对银行家算法的理解。

二、实验环境：

硬件环境：计算机一台，局域网环境；

软件环境：Windows XP及以上版本 Professional操作系统平台，Visual C++ 6.0专业版或企业版。

三、实验指导

1. 银行家算法中的数据结构

(1) 可利用资源向量Available。这是一个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目，其初始值是系统中所配置的该类全部可用资源的数目，其数值随该类资源的分配和回收而动态地改变。如果Available［j］=K，则表示系统中现有Rj类资源K个。

(2) 最大需求矩阵Max。这是一个n×m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。如果Max［i,j］=K，则表示进程i需要Rj类资源的最大数目为K。

(3) 分配矩阵Allocation。这也是一个n×m的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。如果Allocation［i,j］=K，则表示进程i当前已分得Rj类资源的数目为K。

(4) 需求矩阵Need。这也是一个n×m的矩阵，用以表示每一个进程尚需的各类资源数。如果Need［i,j］=K，则表示进程i还需要Rj类资源K个，方能完成其任务。

Need［i,j］=Max［i,j］-Allocation［i,j］

2. 银行家算法

设Requesti是进程Pi的请求向量，如果Requesti［j］=K，表示进程Pi需要K个Rj类型的资源。当Pi发出资源请求后，系统按下述步骤进行检查：

(1) 如果Requesti［j］≤Need［i,j］，便转向步骤2；否则认为出错，因为它所需要的资源数已超过它所宣布的最大值。

(2) 如果Requesti［j］≤Available［j］，便转向步骤(3)；否则，表示尚无足够资源，Pi须等待。

(3) 系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：

Available［j］∶=Available［j］-Requesti［j］;

Allocation［i,j］∶=Allocation［i,j］+Requesti［j］;

Need［i,j］∶=Need［i,j］-Requesti［j］;

(4) 系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。若安全，才正式将资源分配给进程Pi，以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。

3. 安全性算法

(1) 设置两个向量：① 工作向量Work: 它表示系统可提供给进程继续运行所需的各类资源数目，它含有m个元素，在执行安全算法开始时，Work∶=Available; ② Finish: 它表示系统是否有足够的资源分配给进程，使之运行完成。开始时先做Finish［i］∶=false; 当有足够资源分配给进程时，再令Finish［i］∶=true。

(2) 从进程集合中找到一个能满足下述条件的进程： ① Finish［i］=false; ② Need［i,j］≤Work［j］；若找到，执行步骤(3)，否则，执行步骤(4)。

(3) 当进程Pi获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：

Work［j］∶=Work［i］+Allocation［i,j］;

Finish［i］∶=true;

go to step 2;

(4) 如果所有进程的Finish［i］=true都满足，则表示系统处于安全状态；否则，系统处于不安全状态。

四、提示

可以用下面的数据作为测试数据

假定系统中有五个进程｛P0, P1, P2, P3, P4｝和三类资源｛A, B, C｝，各种资源的数量分别为10、5、7，在T0时刻的资源分配情况如图2-1 所示。

图2-1 T0时刻的资源分配表

请求序列

（1）P1发出请求向量Request1(1，0，2)

（2）P4发出请求向量Request4(3，3，0)

（3）P0发出请求向量Requst0(0，2，0)

#include<iostream>
#include<vector>
using namespace std;
const int M = 5;//进程数
const int N = 3;//资源数
int maxRequest[M][N] = { {7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3} };//最大需求矩阵
int available[N] = { 3,3,2 };//可用资源向量 
int allocation[M][N] = { {0, 1,0,} ,{2,0,0},{3,0,2}, {2, 1, 1},{0,0,2} };//己分配资源矩阵 
int need[M][N] = { {7,4,3}, {1,2,2},{6,0,0}, {0,1,1},{4,3,1} };//需求矩阵矩阵 表示每个进程还需要的各类资源的数目
int request[N] = { 0, 0, 0 };//资源请求 
int work[N];
bool Finish[5];

void infInput()
{
	int i, j;
	cout << "请输入最大需求矩阵max\n";
	for (i = 0; i < M; i++)
	{
		for (j = 0; j < N; j++)
		{
			cin >> maxRequest[i][j];
		}
	}
	cout << "请输入分配矩阵allocation\n";
	for (i = 0; i < M; i++)
	{
		for (j = 0; j < N; j++)
		{
			cin >> allocation[i][j];
		}
	}
	cout << "请输入需求矩阵need\n";
	for (i = 0; i < M; i++)
	{
		for (j = 0; j < N; j++)
		{
			cin >> need[i][j];
		}
	}
	cout << "请输入可用资源向量available\n";
	for (i = 0; i < N; i++)
	{
		cin >> available[i];
	}
}


void showmaxRequest() //显示最大需求矩阵 
{
	cout << "max" << endl;
	for (int i = 0; i < M; i++)
	{
		for (int j = 0; j < N; j++)
		{
			cout << maxRequest[i][j] << " ";
		}
		cout << "    ";
	}
	cout << endl;
}
void showallocation() //显示己分配资源矩阵
{
	cout << "allocation" << endl;
	for (int i = 0; i < M; i++)
	{
		for (int j = 0; j < N; j++)
		{
			cout << allocation[i][j] << " ";
		}
		cout << "    ";
	}
	cout << endl;
}
void showneed() //显示每个进程还需要的各类资源的数目
{
	cout << "need" << endl;
	for (int i = 0; i < M; i++)
	{
		for (int j = 0; j < N; j++)
		{
			cout << need[i][j] << " ";
		}
		cout << "    ";
	}
	cout << endl;
}
void show()//显示资源分配情况 
{
	cout << "可用资源数为：" << endl;
	for (int i = 0; i < N; i++)
	{
		cout << "资源" << i << ":" << available[i] << endl;
	}
	cout << "当前的分配情况：" << endl;
	cout << "进程" << endl;
	for (int i = 0; i < 5; i++)//输出5个进程 
	{
		cout << "p" << i << "        ";
	}
	cout << endl;
	showmaxRequest();
	showallocation();
	showneed();
}

//比较函数
//比较进程为m中的元素全大于n中的元素返回1，否则返回0
int compare(int* m, int* n)
{
	int i;
	for (i = 0; i < N; i++)
	{
		if (m[i] < n[i])
		{
			return 0;
		}
	}
	return 1;
}

int Safe()//安全性算法(核心算法)
{
	vector<int>s;
	int work[N];
	int count = 0;
	for (int i = 0; i < N; i++)
	{
		work[i] = available[i];
	}
	int i, j;
	int cnt = 0;
	for (i = 0; i < M; i++)
	{
		Finish[i] = false;//finish表示系统是否有足够的资源分配给进程，开始时，先让每个进程置为false 
	}
	i = 0;
	while (cnt != M)//当cnt等于进程数M时，表示系统处于安全状态 
	{
		if (Finish[i] != true)//查找符合的进程  
		{
			if (compare(work, need[i])) //资源数与j相等，即need中的数都比work小 
			{
				cout << "p" << i << "释放后Allocation为" << endl;
				Finish[i] = true;//找到符合的进程后，将finish置为true 
				for (int j = 0; j < N; j++)
				{
					work[j] = work[j] + allocation[i][j];//进程pi执行完成后，释放分配给它的资源 
					cout << work[j] << "  ";
				}
				cout << endl;
				cnt++;
				s.push_back(i);//将finish为true的进程输入到 vector容器中 
			}
		}
		i++;
		if (i > 4)//i>4时，进程已遍历一遍，令i=0，重新遍历 
		{
			count++;
			i = 0;
		}
		if (count > 2)
		{
			break;
		}
	}
	if (cnt == 5)//安全状态 
	{
		cout << "进程安全!" << endl;
		cout << "安全序列为：" << endl;
		for (auto i : s)
		{
			cout << "p" << i << "->";
		}
		cout << endl;
		return 1;
	}
	else
	{
		cout << "进程不安全,分配不成功" << endl;
		return 0;
	}
}
bool banker(int i) //银行家算法
{
	for (int j = 0; j < N; j++)
	{
		if (request[j] > need[i][j] || request[j] > available[j])//超过它所需要的资源或超过可利用的资源，都为出错 	
		{
			return false;
		}
	}
	for (int j = 0; j < N; j++) //系统试探着把资源分配给进程,并修改相应的数据
	{
		available[j] = available[j] - request[j];
		allocation[i][j] = allocation[i][j] + request[j];
		need[i][j] = need[i][j] - request[j];
	}
	if (Safe())
	{
		return true;//如果安全，则返回
	}
	else//否则，需将试探后 修改的相应数值恢复为原来的资源分配状态，让进程等待 
	{
		for (int i = 0; i < M; i++)
		{
			for (int j = 0; j < N; j++)
			{
				available[j] = available[j] + request[j];
				allocation[i][j] = allocation[i][j] - request[j];
				need[i][j] = need[i][j] + request[j];
			}
		}
		return false;
	}
}
int main()
{
	show();
	int i, x;
	cout << " 请输入请求分配的进程" << endl;
	cin >> i;
	cout << "请输入请求资源数" << endl;
	for (int j = 0; j < N; j++)
	{
		cin >> x;
		request[j] = x;
	}
	banker(i);
	return 0;
}