操作系统：Java模拟银行家算法

---

本人是个新手，写下博客用于自我复习、自我总结。
本人编写算法水平不高，可能会有错误，仅供各位参考。

---

1、系统可用资源=（5，3，8，2，10）
2、若干进程最大需求矩阵如下表所示：

import java.util.Scanner;

public class Bank {
	//用于判断数据输入是否有误 / 用于判断系统是否处于安全状态
	public static boolean judge = true;
	//用于记录手动输入的 每个进程已经占有的资源
	public static int request[][] = new int[6][5];

	public static void main(String args[]) {
		//记录每个资源的资源数
		int available[] = { 5, 3, 8, 2, 10 };
		//记录每个进程需要各个资源的资源数
		int max[][] = { { 3, 3, 5, 0, 5 }, { 5, 3, 8, 1, 2 },
				{ 2, 1, 2, 0, 4 }, { 4, 0, 7, 0, 5 }, { 1, 2, 3, 2, 5 },
				{ 3, 2, 6, 2, 9 } };
		//记录每个进程已经拥有的各个资源的资源数
		int allocation[][] = new int[6][5];
		//记录每个进程还需要各个资源的资源数
		int need[][] = { { 3, 3, 5, 0, 5 }, { 5, 3, 8, 1, 2 },
				{ 2, 1, 2, 0, 4 }, { 4, 0, 7, 0, 5 }, { 1, 2, 3, 2, 5 },
				{ 3, 2, 6, 2, 9 } };
		//记录系统中是否有足够资源分配给进程。false为没分配，true为已分配
		boolean finish[] = { false, false, false, false, false, false };
		//手动输入每个进程已经占有的资源数
		input(need, available, max);
		//只要输入阶段没出错，就进行算法部分
		if (judge) {
			bank(available, max, allocation, need, finish);
		}
	}
	//银行家算法
	static void bank(int ava[], int max[][], int all[][], int need[][], boolean finish[]) {
		//用于判断是否六个进程全部执行完毕
		int count = 0;
		//用于记录进程下标
		int i = 0;
		//用于记录进程的执行顺序
		int arr[] = new int[6];
		//用于记录arr数组的下标
		int count2 = 0;
		//用于判断进程是否处于不安全状态
		int count3 = 0;
		//不断循环，直到判断出系统处于安全状态/不安全状态
		while (true) {
			//只要count3变成了指定的数，就意味着变成了死循环，应立即跳出循环
			if (count3 == 6) {
				//设置false，证明系统处于不安全状态
				judge = false;
				break;
			}
			//用于记录目前匹配成功的进程数
			for (int a = 0; a < 6; a++) {
				if (finish[a] == true) {
					count += 1;
				}
			}
			//如果全部进程匹配成功，意味着系统处于安全状态，应立即跳出循环
			if (count == 6) {
				break;
			} else {
				//只要该进程还没被匹配成功，就进行下述代码
				if (finish[i] == false) {
					System.out.println("现在执行第" + (i + 1) + "个进程：");
					for (int j = 0; j < 5; j++) {
						//只要进程需要每个资源的数目小于系统拥有的每个资源数
						//就意味着能够把该资源分配给进程，就进行下述代码
						//否则，证明该进程成功分配资源，需要立即跳出循环
						if ((need[i][j] - request[i][j]) <= ava[j]) {
							all[i][j] = all[i][j] + request[i][j];
							need[i][j] = need[i][j] - request[i][j];
							System.out.println("在分配后，它还需要" + (j + 1) + "资源" + need[i][j] + "个，系统还能提供" + ava[j] + "个");
							ava[j] = ava[j] + all[i][j];
							if (j == 4) {
								System.out.println("该进程可以分配，满足条件，同时释放资源");
								//证明该资源已经被分配成功
								finish[i] = true;
								//用于记录执行顺序
								arr[count2] = i;
								//改变下标
								count2 += 1;
								//只要匹配成功，匹配失败的数量清零
								count3 = 0;
								break;
							}
						} else {
							System.out.println("该进程在获得第" + (j + 1) + "个资源时，系统只能提供" + ava[j] + "个，进程还需要" + (need[i][j] - request[i][j]) + "个，所以因为资源数量不足而出错");
							//匹配失败的数量+1
							count3 += 1;
							//如果匹配不成功的进程数已经等于还没被匹配的进程数
							//也就意味着永远都无法匹配成功，即出现了死循环
							if (count3 == 6 - count) {
								count3 = 6;
							}
							break;
						}
					}
					//改变下标
					i += 1;
					//如果循环到最后一个进程，就返回第一个进程
					if (i == 6) {
						i = 0;
					}
					//每次循环都要清零，用于重新判断是否每个进程都被成功分配
					count = 0;
				}
			}
		}
		System.out.println("执行完毕");
		//只要是安全状态：
		if (judge) {
			System.out.println("资源分配后，系统处于安全状态。执行顺序是：");
			for (int c = 0; c < 6; c++) {
				System.out.print((arr[c] + 1) + " ");
			}
		} else { //不安全状态
			System.out.println("资源分配后，系统处于不安全状态，无法分配。");
		}
	}
	//用于输入每个进程已经拥有的资源数
	static void input(int need[][], int ava[], int max[][]) {
		for (int i = 0; i < 6; i++) {
			System.out.print("对于第" + (i + 1) + "个进程：");
			System.out.println();
			for (int j = 0; j < 5; j++) {
				System.out.println("您已经占有" + (j + 1) + "资源多少个？");
				Scanner sc = new Scanner(System.in);
				int contents = sc.nextInt(); 
				//如果输入的资源数超过以下限定，那就证明输入数据有误，立即跳出循环
				if (contents > need[i][j] && contents > ava[j]
						&& contents > max[i][j]) {
					System.out.println("输入数据有误，不满足当前条件");
					judge = false;
					break;
				} else {
					//否则满足输入条件，就进行记录
					request[i][j] = contents;
					//同时分配成功后，需要减少原本资源数量
					ava[j] = ava[j] - request[i][j];
				}
			}
			//输入数据有误，跳出循环
			if (!judge) {
				break;
			}
		}
	}
}