java实现银行家算法

package items_7;

import java.util.ArrayList;
import java.util.Scanner;

public class banker {
	//判断安全序列里是否已有某序列
	public static boolean isExist(int[] safeList,int k){
		int flag=0;
		for(int i=0;i<safeList.length;i++){
			if(safeList[i]==k){
				flag=1;
			}
		}
		if(flag==1){
			return true;
		}
		return false;
	}
	
	//判断是否都为真
	public static boolean isTrue(boolean[] fflag,int k){
		int n=0;
		for(int i=0;i<fflag.length;i++){
			if(fflag[i]){
				n++;
			}
		}
		if(n==k){
			return true;
		}
		return false;
	}
	
	public static void main(String argv[]){
		Scanner sc=new Scanner(System.in);
		System.out.print("请输入进程个数：");
		int threadNum=sc.nextInt();
		System.out.print("请输入资源个数：");
		int resourceNum=sc.nextInt();
		
		//第几个资源的数量
		int[] resourceArray=new int [resourceNum];
		for(int i=0;i<resourceNum;i++){
			System.out.print("请输入第"+(i+1)+"个资源的数量：");
			resourceArray[i]=sc.nextInt();
		}
		
		//对数组初始化为0
		int[] maxSum=new int[resourceNum]; //对第几个资源的最大需求求和
		for(int i=0;i<resourceNum;i++){ 
			maxSum[i]=0; //初始化为0
		}
		//每个进程对每个资源的最大需求
		int[][] max=new int [threadNum][resourceNum];
		System.out.println("输入每个进程对每个资源的最大需求:");
		for(int i=0;i<threadNum;i++){
			for(int j=0;j<resourceNum;j++){
				System.out.print("输入第"+i+"个进程对第"+j+"个资源的最大需求:");
				max[i][j]=sc.nextInt();
			}
		}
		
		//对数组初始化为0
		int[] allocationSum=new int[resourceNum]; //对第几个资源的已分配资源求和
		for(int i=0;i<resourceNum;i++){ 
			allocationSum[i]=0; //初始化为0
		}
		//每个进程对每个资源的已分配资源数量
		int[][] allocation =new int [threadNum][resourceNum];
		System.out.println("输入每个进程对每个资源的已分配资源数量：");
		for(int i=0;i<threadNum;i++){
			for(int j=0;j<resourceNum;j++){
				System.out.print("输入第"+i+"个进程对第"+j+"个资源的已分配资源数量:");
				allocation[i][j]=sc.nextInt();
			}
		}
		//求和
		for(int i=0;i<resourceNum;i++){
			for(int j=0;j<threadNum;j++){
				allocationSum[i]+=allocation[j][i]; 
			}
		}
		
		//现需求进程资源数
		int[][] needSum=new int[threadNum][resourceNum];
		for(int i=0;i<threadNum;i++){
			for(int j=0;j<resourceNum;j++){
				needSum[i][j]=max[i][j]-allocation[i][j];
			}
		}
		
		//输出测试
		/*for(int i=0;i<threadNum;i++){
			for(int j=0;j<resourceNum;j++){
				System.out.println("现需求资源数：");
				System.out.println(needSum[i][j]);
			}
		}*/
		
		
		//剩余可用数组
		int[] available=new int[resourceNum];
		for(int i=0;i<resourceNum;i++){
			available[i]=resourceArray[i]-allocationSum[i];
		}
		
		//输出测试
		/*for(int i=0;i<resourceNum;i++){
			System.out.println(available[i]);
		}*/
		
		//寻找安全序列第一个值
		int flag=0;
		
		int k=0; //安全序列索引
		int[] safeList=new int[threadNum]; //最后输出的安全序列
		boolean[] fflag=new boolean[resourceNum];
		for(int i=0;i<threadNum;i++){ 
			safeList[i]=-1; //初始化为-1
		}
		
		for(int i=0;i<threadNum;i++){
			for(int a=0;a<resourceNum;a++){ 
				fflag[a]=false; //初始化为false
			}
			if(isExist(safeList,i)){
				continue;
			}
			for(int j=0;j<resourceNum;j++){
				if(available[j]>=needSum[i][j]){
					fflag[j]=true;
				}
			}
			if(isTrue(fflag,resourceNum)){
				System.out.println(i); //i这行就是安全序列第一个
				safeList[k++]=i;
				for(int m=0;m<resourceNum;m++){
					available[m]+=allocation[i][m];
					System.out.println(available[m]);
				}
				i=-1; //重新循环
			}
			if(k==threadNum){
				flag=1;
				break;
			}
		}
		
		//输出最后结果
		if(flag==0){
			System.out.print("该实例没有安全序列.");
		}else{
			System.out.print("该实例的安全序列为：");
			for(int i=0;i<k;i++){
				System.out.print(safeList[i]);
				System.out.print(",");
			}
		}
	}
}

我的测试结果如下：

请输入进程个数：5
请输入资源个数：3
请输入第1个资源的数量：10
请输入第2个资源的数量：5
请输入第3个资源的数量：7
输入每个进程对每个资源的最大需求:
输入第0个进程对第0个资源的最大需求:7
输入第0个进程对第1个资源的最大需求:5
输入第0个进程对第2个资源的最大需求:3
输入第1个进程对第0个资源的最大需求:3
输入第1个进程对第1个资源的最大需求:2
输入第1个进程对第2个资源的最大需求:2
输入第2个进程对第0个资源的最大需求:9
输入第2个进程对第1个资源的最大需求:0
输入第2个进程对第2个资源的最大需求:2
输入第3个进程对第0个资源的最大需求:2
输入第3个进程对第1个资源的最大需求:2
输入第3个进程对第2个资源的最大需求:2
输入第4个进程对第0个资源的最大需求:4
输入第4个进程对第1个资源的最大需求:3
输入第4个进程对第2个资源的最大需求:3
输入每个进程对每个资源的已分配资源数量：
输入第0个进程对第0个资源的已分配资源数量:0
输入第0个进程对第1个资源的已分配资源数量:1
输入第0个进程对第2个资源的已分配资源数量:0
输入第1个进程对第0个资源的已分配资源数量:2
输入第1个进程对第1个资源的已分配资源数量:0
输入第1个进程对第2个资源的已分配资源数量:0
输入第2个进程对第0个资源的已分配资源数量:3
输入第2个进程对第1个资源的已分配资源数量:0
输入第2个进程对第2个资源的已分配资源数量:2
输入第3个进程对第0个资源的已分配资源数量:2
输入第3个进程对第1个资源的已分配资源数量:1
输入第3个进程对第2个资源的已分配资源数量:1
输入第4个进程对第0个资源的已分配资源数量:0
输入第4个进程对第1个资源的已分配资源数量:0
输入第4个进程对第2个资源的已分配资源数量:2
1
5
3
2
3
7
4
3
0
7
5
3
2
10
5
5
4
10
5
7
该实例的安全序列为：1,3,0,2,4,

测试数据（引用自https://blog.youkuaiyun.com/qq_34902437/article/details/82936161）：