计算机操作系统-处理机调度与死锁篇

计算机操作系统-处理机调度与死锁篇：

---

内容：

1. 银行家算法习题
2. 银行家算法-实训代码-C语言实现

---

1.银行家算法习题

算法介绍：

点击查看百度百科银行家算法或者翻书P100，名词解释自己看，银行家算法由两部分组成：银行家算法+安全性算法。
我们需要知道算法中的数据结构：Available(可利用资源向量)、Max(最大资源矩阵)、Allocation(分配矩阵)、Need(需求矩阵)且存在下列关系：Need[i,j]=Max[i,j]-Allocation[i,j]

题目:在银行家算法中，若出现下述资源分配情况：

1.1 思路：

第一小题问的是该状态是否安全，实际上考的是银行家算法中的安全性算法，原理在上面已经看过了，简单来说，就是找出一个安全序列，是否能推进后续进程，值得注意的是，同一个状态下也可能出现多种安全序列，答案并不唯一，根据对比资源总量可以判断出计算是否出错。

1. 由表可得可利用资源Available为1 6 2 2，新增加一个资源名work，work=Available，当前5个进程的需求Need只有进程P0是可满足的，所以将资源分配给P0，执行进程P0
2. 进程P0结束后，当前可利用资源Available=之前的Available即work+进程P0已分配的资源Allocation=1 6 2 2+0 0 3 2=1 6 5 4，查看当前可利用资源是否满足剩下进程所需资源，只有P3是可满足的，所以将资源分配给P3，执行进程P3
3. 进程P0结束后，当前可利用资源Available=1 6 5 4+0 3 3 2=1 9 8 6可以满足P1和P4
   (1)选择P1:进程P1结束后，当前可利用资源Available=1 9 8 6+1 0 0 0=2 9 8 6可以满足P2和P4，两个随便选一个，最终运行完毕
   (2)选择P4:进程P4结束后，当前可利用资源Available=1 9 8 6+0 0 1 4=1 9 9 10可以满足P1，然后运行P1再运行P2即可结束
4. 验算：将最后的资源总量与系统的资源总量进行对比，一致则说明计算过程无误

1.1 答案：

由上述思路可得安全序列有三个分别为：
P0->P3->P1->P2->P4
P0->P3->P1->P4->P2
P0->P3->P4->P1->P2

1.2 思路：

这题考察的是银行家算法，四个步骤，原理自己去看

1. 请求是否合理：判断该进程提出的Request请求资源是否超出其本身所需的资源即Request[j]<= Need[i,j]
2. 当前资源是否满足：判断该进程提出的Request请求资源是否超出系统可利用资源即Request[j]<= Available[j]
3. 尝试假定分配：可利用资源、该进程所需资源相应减少、该进程已分配资源相应增加即
   Available[j]=Available[j]-Request[j]
   Allocation[i,j]=Allocation[i,j]+Request[j]
   Need[i,j]=Need[i,j]-Request[j]
4. 运行安全性检查：找出一个安全序列，如果找不到则假定分配作废，操作回退

1.2 答案：

---

2.实训代码

代码如下：

#include <stdio.h>
#define Maxsize 10
void show (int avaliable[],int max[][Maxsize],int allocation[][Maxsize],int need[][Maxsize],int m,int n) {
	printf("-----当前系统资源情况-----\n");
	printf("进程\tMax\t\tAllocation\tNeed\t\tAvaliable\t");
	for (int i=0; i<n; i++) {
		printf("\nP%d\t",i+1);
		for (int j=0; j<m; j++) {
			printf("%d ",max[i][j]);
		}
		putchar('\t');
		for (int j=0; j<m; j++) {
			printf("%d ",allocation[i][j]);
		}
		putchar('\t');
		for (int j=0; j<m; j++) {
			printf("%d ",need[i][j]);
		}
	}
	putchar('\t');
	for (int j=0; j<m; j++) {
		printf("%d ",avaliable[j]);
	}
	putchar('\n');
}
int safe(int avaliable[],int max[][Maxsize],int need[][Maxsize],int allocation[][Maxsize],int m,int n) {
	int finish[Maxsize]= {1},safeseq[Maxsize]= {0},work[Maxsize],safe_need[Maxsize][Maxsize],safe_allocation[Maxsize][Maxsize];
	int resta,i,j,k=0;
	for (i=0; i<n; i++) {
		finish[i]=0;
		for (j=0; j<m; j++) {
			work[j]=avaliable[j];
			safe_need[i][j]=need[i][j];
			safe_allocation[i][j]=allocation[i][j];
		}
	}
	printf("\n-------进入安全性检查-------\n");
	for (i=0; i<n; i++) {
		resta=0;
		for (j=0; j<m; j++) {
			if (finish[i]==0 && safe_need[i][j]<=work[j])
				resta++;
		}
		if (resta==m) {
			for (j=0; j<m; j++) {
				work[j]+=safe_allocation[i][j];
			}
			finish[i]=1;
			safeseq[k++]=i;
			i=-1;
		}
	}

	for (i=0; i<n; i++) {
		if (!finish[i]) {
			printf("This Not safe!");
			return 0;
		} else {
			printf("This is safe!\n安全序列为：");
			for (j=0; j<n; j++) {
				printf("%d ",safeseq[j]);
			}
			return 1;
		}
	}
	//show(work,max,allocation,need,m,n);
}
int yhj(int avaliable[],int max[][Maxsize],int need[][Maxsize],int allocation[][Maxsize],int m,int n) {
	int x,resta,f,j,request[Maxsize];
	printf("\n-------进入银行家算法-------\n");
	printf("请输入提出的request的进程:");
	scanf("%d",&x);
	printf("请输入提出的request资源量:");
	for (int i=0; i<m; i++) {
		scanf("%d",&request[i]);
	}
	x--;
	resta=f=0;
	for (j=0; j<m; j++) {
		if (request[j]<=need[x][j]) {
			//printf("request请求合理\n");
			if (request[j]<=avaliable[j]) {
				resta++;
			} else {
				printf("ERROR! 可用资源不满足request请求资源");
				return 0;
			}
		} else {
			printf("ERROR! request请求资源超出该进程所需资源");
			return 0;
		}
	}
	for (j=0; j<m; j++) {
		if (resta==m) {
			printf("可用资源满足请求，进行假定分配\n");
			avaliable[j]-=request[j];
			allocation[x][j]+=request[j];
			need[x][j]-=request[j];
			f=1;
		}
	}
	show(avaliable,max,allocation,need,m,n);
	if(f) {
		if(safe(avaliable,max,need,allocation,m,n)) {
			printf("request请求已通过安全性检查，系统已成功分配\n");
		} else {
			printf("request请求未通过安全性检查，假定分配失败\n");
			for (int j=0; j<m; j++) {
				avaliable[j]+=request[j];
				allocation[x][j]-=request[j];
				need[x][j]+=request[j];
			}
		}
	}
//show(avaliable,max,allocation,need,m,n);
}
int main() {
	int n,m,i,j;
	int avaliable[Maxsize],max[Maxsize][Maxsize],allocation[Maxsize][Maxsize],need[Maxsize][Maxsize];
	printf("请输入共有资源种类数：");
	scanf("%d",&m);
	printf("请输入总资源量为：");
	for (i=0; i<m; i++) {
		scanf("%d",&avaliable[i]);
	}
	printf("请输入进程数：");
	scanf("%d",&n);
	for (i=0; i<n; i++) {
		printf("请输入进程P%d，所需最大资源量:",i+1);
		for (j=0; j<m; j++) {
			scanf("%d",&max[i][j]);
		}
		printf("请输入进程P%d，已拥有的资源量:",i+1);
		for (j=0; j<m; j++) {
			scanf("%d",&allocation[i][j]);
			need[i][j]=max[i][j]-allocation[i][j];
			avaliable[j]-=allocation[i][j];
		}
		putchar('\n');
	}
	show(avaliable,max,allocation,need,m,n);
	yhj(avaliable,max,need,allocation,m,n);
	putchar('\n');
	show(avaliable,max,allocation,need,m,n);
	return 0;
}

效果：

---