操作系统原理银行家算法

---

一、 题目要求

测试数据：m=3:种类型的资源（A,B,C,） 进程个数 n=5 Available=(2,3,3);
已分配资源数量 资源需求量
****A B C ******* A B C
P1 2 1 2 ******** 3 4 7
P2 4 0 2 ******** 1 3 4
P3 3 0 5 ******** 0 0 3
P4 2 0 4 ******** 2 2 1
P5 3 1 4 ******** 1 1 0
请求序列如下：
a: 进程 P2 请求资源（0，3，4）
b 进程 P4 请求资源（1，0，1）
c. 进程 P1 请求资源（2，0，1）
d. 进程 P3 请求资源（0，0，2）
尝试进行分配资源，并进行安全状态判别算法。

二、程序功能及设计思路

需求分析：银行家算法是一种最有代表性的避免死锁的算法。在避免死锁方法中允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。为实现银行家算法，系统必须设置仍可利用的资源，最大需求矩阵，分配矩阵，进程尚需的资源数四个数据结构。
安全状态判别算法也需要依赖以上四种数据结构得以实现。
所以程序功能必须含有试探分配，和判别系统是否处于安全状态。
设计思路：银行家算法：
设 Request是进程Pi的请求向量，如果 Requesti[j] = K，表示进程Pi需要K个j类型的资源。当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等待。
安全状态判别算法：
(1)设置 Finish=(false,…,false) work=Available
(2)循环查找满足下列条件的进程 pi //最多循环 n 次 Finish[i]=false 且 Needi<=work
(3)若找到则 Finish[i]=true;work=work+Alloci; 转(2)
(4)若 Finish=(true,…,true) 则安全，否则不安全。

三、数据结构及算法设计

（1）设计：数据结构
系统可用（剩余）资源:int available[n]
进程的最大需求:int maxRequest[m][n]
进程已经占有（分配）资源: int allocation[m][n]
进程还需要资源int need[m][n]
是否安全:bool Finish[m]
安全序列号:int safeSeries[m]
进程请求资源量int request[n]
（2）算法设计
显示当前状态

void showInfo()
{
	cout << "当前系统各类资源剩余:";
	for (int j = 0; j < n; j++)
	{
		cout << available[j] << " ";
	}
	cout << endl;
	cout << "当前系统资源情况：" << endl;
	cout << "进程号" << "\t" << "对资源的总需求" << "          " << "已分配的资源" << "         " << "还需要的资源" << endl;
	for (int i = 0; i < m; i++)
	{
		cout << "P" << i + 1 << "          ";
		for (int j = 0; j < n; j++)
		{
			cout << maxRequest[i][j] << "  ";
		}
		cout << "\t\t";
		for (int j = 0; j < n; j++)
		{
			cout << allocation[i][j] << "  ";
		}
		cout << "\t\t";
		for (int j = 0; j < n; j++)
		{
			cout << need[i][j] << "  ";
		}
		cout << endl;
	}
}

安全检查

bool isSafe()//安全检查
{
	//int nFinish = 0;
	int safeIndex = 0;
	int allFinish = 0;
	int work[n] = { 0 };
	int r = 0;
	int temp = 0;
	int pNum = 0;
	//预分配为了保护available[]
	for (int i = 0; i < n; i++)
	{
		work[i] = available[i];
	}
	//把未完成进程置为false
	for (int i = 0; i < m; i++)
	{
		bool result = isAllZero(i);
		if (result == true)
		{
			Finish[i] = true;
			allFinish++;
		}
		else
		{
			Finish[i] = false;
		}

	}
	//预分配开始
	while (allFinish != m)
	{
		num = 0;
		for (int i = 0; i < n; i++)
		{
			if (need[r][i] <= work[i] && Finish[r] == false)
			{
				num++;
			}
		}
		if (num == n)
		{
			for (int i = 0; i < n; i++)
			{
				work[i] = work[i] + allocation[r][i];
			}
			allFinish++;
			SafeInfo(work, r);
			safeSeries[safeIndex] = r;
			safeIndex++;
			Finish[r] = true;
		}
		r++;//该式必须在此处	
		if (r >= m)
		{
			r = r % m;
			if (temp == allFinish)
			{
				break;
			}
			temp = allFinish;
		}
		pNum = allFinish;
	}
	//判断系统是否安全
	for (int i = 0; i < m; i++)
	{
		if (Finish[i] == false)
		{
			cout << endl;
			cout << "当前系统不安全" << endl;
			return false;
		}
	}
	//打印安全序列
	cout << endl;
	cout << "当前系统安全！" << "安全序列为：";
	for (int i = 0; i < m; i++)
	{
		bool result = isAllZero(i);
		if (result == true)
		{
			pNum--;
		}
	}
	for (int i = 0; i < pNum; i++)
	{	cout << safeSeries[i] + 1 << " ";}
	return true;
}

判断一个进程的资源是否全为零

bool isAllZero(int kang)
{
	num = 0;
	for (int i = 0; i < n; i++)
	{
		if (need[kang][i] == 0)
		{
			num++;
		}
	}
	if (num == n)
	{		return true;	}
	else
	{	return false;	}
}

四、程序运行情况

五、遇到的困难及解决办法、实习心得或良好建议

遇到的困难:安全判别算法中当第一次将finish数组修改完后，如果数组中都为true则很好判断该系统安全，但不能因为其中仍存在false而判断该系统不安全。
解决办法：当遍历一轮都没有找到一个可以安全执行的进程，则可说明该系统不安全。
记录 Finish[i] = true 的次数，同时把这个次数再使用另一个变量存放起来，然后在判断语句当中判断当寻找一轮下来，该值未发生改变，说明已经找不到安全的进程了，即可跳出循环。
实习心得：加深了对银行家算法的理解。