操作系统实验模拟银行家算法

实验银行家算法

1. 实验目的

死锁会引起计算机工作僵死，因此操作系统中必须防止。本实验的目的在于让学生独立的使用高级语言编写和调试一个系统动态分配资源的简单模拟程序，了解死锁产生的条件和原因，并采用银行家算法有效地防止死锁的发生，以加深对课堂上所讲授的知识的理解。

2. 实验内容

1、银行家算法
设 Reguest i是进程 P i的请求向量，如果 Requesti [j]= K ，表示进程 P i需要 K 个 R j类型的资源。当 Pi 发出资源请求后，系统按下述步骤进行检查：
(1）如果 Requestlj]≤ Need [ i , j ]，便转向步骤（2)；否则认为出错，因为它所需要的资源数已超过它所宣布的最大值。
(2）如果 Request i[ j ]≤ Available [j]，便转向步骤（3)；否则，表示尚无足够资源， P i须等待。
(3)系统试探着把资源分配给进程 P i，并修改下面数据结构中的数值：
Available [ j ]= Available [ j ]- Request i[ j ];
Alocation [ i , j ]= Alocation [ i , j ]+ Request [ jl ;
Need [ i , j ]= Need [ i , j ]- Request i[ jl ;
(4）系统执行安全性算法，检查此次资源分配后系统是否处于安全状态。若安全，才正式将资源分配给进程 Pi以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程 P i等待。
2、安全性算法
1）．设置两个向量。Work：它表示系统可提供给进程继续运行的各类资源数目，它包含m个元素，开始执行安全性算法时，Work = Available。Finish：它表示系统是否有足够的资源分配给进程，使之运行完成，开始Finish（I）=false；当有足够资源分配给进程Pi时，令Finish（i）=true；
2）．从进程集合中找到一个能满足下述条件的进程。Finish（i）= = false；Need i≤work；如找到则执行步骤3；否则，执行步骤4；
3）．当进程Pi获得资源后，可顺利执行直到完成，并释放出分配给它的资源，故应执行Work= work +AllocationiFinish（i）=true；转向步骤2；
4）．若所有进程的Finish（i）都为true，则表示系统处于安全状态；否则，系统处于不安全状态。

3. 实验要求

设计有n个进程共享m个系统资源的系统，进程可动态的申请和释放资源，系统按各进程的申请动态的分配资源。系统能显示各个进程申请和释放资源，以及系统动态分配资源的过程，便于用户观察和分析；

4. 实验代码

#include<iostream>
#include<vector>
using namespace std;
vector<int> Available;
int m, n;
class bankerAlgorithm
{
public:
	int Max[100];
	int Allocation[100];
	int need[100];
};
void Banker(vector<bankerAlgorithm> banker);
void show(vector<bankerAlgorithm> banker);
bool lower(bankerAlgorithm a, vector<int>work);
bool safe(vector<bankerAlgorithm> banker);
void initialize();
class random   //取随机数
{
public:
	static inline int getRandom(const int min, const int max, int match)
	{
		srand(time(0) + match);
		return rand() % (max - min - 1) + min;
	}
	static inline int getRandom(const int min, const int max, int match1,int match2)
	{
		srand(time(0) + match1+match2);
		return rand() % (max - min - 1) + min;
	}
};
void Banker(vector<bankerAlgorithm> banker)
{
	int t = 1;
	while(1)
	{
		cout << "请输入需要申请资源的进程：" << endl;
		cin >> t;
		if (t <= n && t >= 1)
		{
			t--;
			cout << "请输入各资源申请量：" << endl;
			vector<int>request;
			for (int i = 0; i < m; i++)
			{
				int temp1;
				cin >> temp1;
				request.push_back(temp1);
			}
			if (lower(banker[t], request))
			{
				cout << "数据出错" << endl;
				continue;
			}
			for (int i = 0; i < m; i++)
			{
				if (request[i] > Available[i])
				{
					cout << "数据出错" << endl;
					continue;
				}
			}
			for (int j = 0; j < m; j++)
			{
				Available[j] -= request[j];
				banker[t].Allocation[j] += request[j];
				banker[t].need[j] += request[j];
			}
			if (safe(banker) == true)
			{
				cout << "系统安全，允许分配" << endl;
			}
			else
				cout << "系统不安全，不允许分配" << endl;
		}
		else
			break;
	} 
	if(t > n || t < 1)
	{
		cout << "您选择终止程序" << endl;
		return;
	}
}
void show(vector<bankerAlgorithm> banker)
{
	cout << endl << endl << endl;
	cout << "系统可分配资源：" << endl;
	cout << "Available==               ";
	for (int i = 0; i < m; i++)
	{
		cout << Available[i] << " ";
	}
	cout << endl;
	for (int i = 0; i < n; i++)
	{
		cout << "第" << i + 1 << "个进程的资源情况为：" << endl;
		cout << "Max==                     ";
		for (int j = 0; j < m; j++)
		{
			cout << banker[i].Max[j] << "  ";
		}
		cout << endl;
		cout << "Allocation==              ";
		for (int j = 0; j < m; j++)
		{
			cout << banker[i].Allocation[j] << "  ";
		}
		cout << endl;
		cout << "need==                    ";
		for (int j = 0; j < m; j++)
		{
			cout << banker[i].need[j] << "  ";
		}
		cout << endl;
	}

}
bool lower(bankerAlgorithm a, vector<int>work)
{
	for (int j = 0; j < m; j++)
	{
		if (a.need[j] > work[j])
			return false;
	}
	return true;
}
bool safe(vector<bankerAlgorithm> banker)
{
	vector<int>work = Available;
	vector<bool>finish;
	vector<int>num;
	for (int i = 0; i < n; i++)
	{
		finish.push_back(false);
	}
	for (int k = 0; k < n; k++)
	{
		for (int i = 0; i < n; i++)
		{
			if (finish[i] == false)
			{
				if (lower(banker[i], work) == true)
				{
					num.push_back(i);
					finish[i] = true;
					for (int j = 0; j < m; j++)
					{
						work[j] = work[j] + banker[i].Allocation[j];
					}
				}
				
			}
		}
	}
	for (int i = 0; i < n; i++)
	{
		if (finish[i] == false)
		{
			cout << "该序列不安全" << endl;
			return false;
		}
	}
	cout << "安全序列为：";
	for (int i = 0; i < n; i++)
		cout << num[i] + 1 << " ";
	cout << endl;
	return true;
}
void initialize()
{
	vector<bankerAlgorithm> banker;
	cout << "请输入资源数:" << endl;
	cin >> m;
	cout << "请输入进程数:" << endl;
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		bankerAlgorithm a;
		for (int j = 0; j < m; j++)
		{
			a.Max[j] = random::getRandom(10, 20, i, j);
		}
		for (int j = 0; j < m; j++)
		{
			a.Allocation[j] = random::getRandom(0, 5, i, j);
		}
		for (int j = 0; j < m; j++)
		{
			a.need[j] = a.Max[j] - a.Allocation[j];
		}
		banker.push_back(a);
	}
	int t = rand() % n;
	for (int j = 0; j < m; j++)
	{
		Available.push_back(random::getRandom(2, 6, j) + banker[t].need[j]);
	}
	show(banker);
	if (safe(banker) == true)
	{
		Banker(banker);
	}
}
int main()
{
	initialize();
	return 0;
}