经典调度问题：银行家算法

什么是银行家算法

银行家算法是操作系统比较经典的调度算法，它比较好的防止了死锁的出现，增加了系统的安全性。

程序流程图

算法实现

import java.util.ArrayDeque;
import java.util.Queue;
import java.util.Scanner;


public class bank {
	static	Scanner scanner=new Scanner(System.in);
	static int n;//进程数量
	static int m;//资源种类数
	static int[] available;
	static int max[][];//最大需求矩阵
	static int allocation[][];//当前分配到每个进程的
	static int need[][];//需求矩阵
	static boolean[] isrelesed;//资源是否已经释放
	/*
	 * 输出状态
	 */
	static void getstatus() {
		for(int i=0;iavailable[j]) {
					jud=true;
				}
			}
			if (jud) {
				System.out.println("最大需求输入有误,请重新赋值(m个数)");
				i--;
			}
		}
		System.out.println("n个线程m种资源最大需求赋值完成\n请输入当前进程已分配资源情况");
		//初始化allocate矩阵
		for(int i=0;imax[i][j]) {
					jud=true;
				}
			}
			if (jud) {
				System.out.println("输出有误,请重新输入:");
				i--;
			}
		}
		System.out.println("allocate(当前已分配矩阵已经分配完毕)");
	}
	private static boolean issafety(int work[],boolean finish[],int need2[][],int allocate2[][])//模拟的需求和分配
	{
		//int work[]=available.clone();//不能直接等于复制。可以了解下对象克隆或者深浅复制。
	    Queueq1=new ArrayDeque();//如果能完成的队列
	    int time=0;
	    while(true)
	    {
	    	boolean loop=true;
	    	for(int i=0;in) {return false;}
	    }
		//return false;
	}
	/*
	 * 假设分配
	 */
	private static boolean ifallocate(int index,int[] request) {
		//首先要将真的数组克隆,模拟已经给资源,然后判断这个资源是否安全
		int work[] = available.clone();
		boolean finish[]= isrelesed.clone();
		int need2[][]=new int[n][m];
		int allocate2[][]=new int[n][m];
		for(int i=0;iindex||index>=n) {
			System.out.println("输入的编号不在编号范围之内,请重新输入");
			index=scanner.nextInt();
			while(isrelesed[index]) {
				System.out.println("改编已经完成资源的释放,无法再请求资源,请重新输入");
				index=scanner.nextInt();
				while(0>index||index>n) {
					System.out.println("输入的编号不在编号范围之内,请重新输入");
					index=scanner.nextInt();
					System.out.println("请输入"+m+"个资源申请的个数(不申请的资源用0替代)");
					int team=0;
					while(team==0) {
						for(int i=0;iavailable[i]) {
								team=1;
							}
							if (request[i]>max[index][i]) {
								team=2;
							}
						}
						if (team==1) {
							System.out.println("您的请求量超出了系统提供量,请重新输入");
							team=0;
						}else if(team==2) {
							System.out.println("您的请求量超出了最大请求量max,请重新输入");
							team=0;
						}else {
							team=3;
						}
						boolean isfinish=ifallocate(index,request);
						if (isfinish) {
							System.out.println("所有进程完成资源分配,分配结束");
							System.exit(0);
						}
					}
				}
			}
		}
	}
	
	
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("请输入资源种类数m:");
		m=scanner.nextInt();
		initm(m);
		System.out.println("输入进程数量n:");
		n=scanner.nextInt();
		initn(n);
		while(true) {
		applyresourse();//申请资源
		}
	}

}

算法分析

假设银行总金额10，客户分期借款，比如A借6，6，6银行还剩4，4，4，此时这个银行最多只能借2，2，2给其他人，因为银行要能保证能在下一次借出钱，即满足A还的钱能够满足其他人的最大需求，6=2*3.

	static int n;//进程数量
	static int m;//资源种类数
	static int[] available;
	static int max[][];//最大需求矩阵
	static int allocation[][];//当前分配到每个进程的
	static int need[][];//需求矩阵
	static boolean[] isrelesed;//资源是否已经释放

这些变量是在安全状态下的真实变量其中:

• n是线程的数量，m是资源的种类。
• Available[]是当前还可以使用的资源。也就是银行家手中还剩余各种钱的数量。只跟资源有关
• Max[][]是最大需求矩阵，也可以理解为最终终态矩阵，因为这个max的状态就是客户想达到和满足的状态。也就是线程可以释放的状态。
• Allocate[][]是已分配矩阵。就是客户已经借到的钱。也就是线程已经占有的资源量
• Need[][]是还需要资源情况，由max和allcate决定。
• Isrelese[]这个数组和线程有关和资源无关，它记录的就是线程是否达到终态，完成资源释放的情况，，一旦完成借钱就不需要借钱。

初始化：

借钱：