Java版银行家算法

package com.feifei.banker;

import java.io.*;

public class Banker {
 // 剩余资源量,初始值是系统中所配置的该类全部可用资源的数目
 int available[];

 // 每个进程的最大需求量
 int max[][];

 // 各个进程尚需的资源量
 int need[][];

 // 已经为每个进程提供的数量
 int allocated[][];

 // 资源种类
 int resourceType;

 // 进程数量
 int processCount;

 boolean echo = true;

 // 从System.in读数据
 BufferedReader br;

 public static void main(String args[]) {
  Banker banker = newBanker();
  banker.init();
  banker.display();
  banker.allocateResource();
 }

 void init() {
  try {
   br = newBufferedReader(new InputStreamReader(System.in));
  } catch (Exception e) {
   e.printStackTrace();
   System.exit(0);
  }

  System.out.println("===银行家算法演示程序===");
  System.out.print("请输入资源种类数:");
  // 从屏幕获得输入的资源数量
  resourceType = readInt();
  // 资源种类数量array
  available = newint[resourceType];

  System.out.print("请输入资源个数向量,共"+ resourceType + "个整数,以空格分隔:/n");
  // 资源种类数量array初始化
  available = readIntArray();

  System.out.print("请输入进程个数:");
  // 从屏幕获得输入的进程数量
  processCount = readInt();
  // 各进程需要的各类资源的最大数矩阵
  max = newint[processCount][resourceType];
  // 各进程已分配的各类资源的数量矩阵
  allocated = newint[processCount][resourceType];
  // 各进程尚需要的各类资源的数量矩阵
  need = newint[processCount][resourceType];

  System.out.print("请输入进程的最大资源需求量矩阵(max矩阵,每行"+ resourceType
    +"个整数,以空格分隔,共" + processCount + "行):/n");
  for (int i = 0; i< processCount; i++)
   max[i] =readIntArray();

  System.out.print("请输入进程的已分配资源量矩阵(allocated矩阵,每行"+ resourceType
    +"个整数,以空格分隔,共" + processCount + "行):/n");
  for (int i = 0; i< processCount; i++)
   allocated[i]= readIntArray();
  for (int i = 0; i< resourceType; i++)
   for (int j =0; j < processCount; j++)
    //计算出need矩阵
    need[j][i]= max[j][i] - allocated[j][i];

  for (int i = 0; i< resourceType; i++)
   for (int j =0; j < processCount; j++) {
    //重新计算available矩阵
    available[i]-= allocated[j][i];
    if(available[i] < 0) {
     System.out.println("错误:第"+ (i + 1)
       +"个可用资源数不足以分配给进程,请检查资源总量和已分配资源矩阵!");
     System.exit(0);
    }
   }
 }

 
 void display() {
  System.out.print("===当前状态:");
  if (safeOrNot())
   System.out.println("安全");
  else
   System.out.println("不安全");
  System.out.println("Max矩阵:");
  printMatrix(max);
  System.out.println("Allocated矩阵:");
  printMatrix(allocated);
  System.out.println("Need矩阵:");
  printMatrix(need);
  System.out.println("available向量:");
  printMatrix(available);
  System.out.println("安全状态:" +safeOrNot());
 }

 void printMatrix(int matrix[]) {
  if (matrix == null)
   return;
  System.out.print("[");
  for (int i = 0; i< matrix.length; i++) {
   System.out.print(matrix[i]);
   if (i + 1< matrix.length)
    System.out.print("/t");
  }
  System.out.println("]");
 }

 void printMatrix(int matrix[][]) {
  if (matrix == null)
   return;
  for (int i = 0; i< matrix.length; i++) {
   System.out.print("[");
   for (int j =0; j < matrix[0].length; j++) {
    System.out.print(matrix[i][j]);
    if(j + 1 < matrix[i].length)
     System.out.print("/t");
   }
   System.out.println("]");
  }
 }

 void allocateResource() {
  while (true) {
   System.out.print("请输入资源请求进程编号:/n");
   int processID= readInt();
   System.out.print("请输入资源请求向量,共"+ resourceType + "个整数,以空格分隔:/n");
   int request[]= readIntArray();
   if(!smallerVector(request, need[processID])) {
    System.out.println("资源请求不符该进程的需求量.");
   } else if(!smallerVector(request, available)) {
    System.out.println("可用资源不足以满足请求,进程阻塞等待.");
   } else{
    subVector(available,request);
    addVector(allocated[processID],request);
    subVector(need[processID],request);
    if(safeOrNot()) {
     //判断所有进程是否是安全序列
     display();
    }else {
     System.out.println("不安全!");
     addVector(available,request);
     subVector(allocated[processID],request);
     addVector(need[processID],request);
    }
   }
   System.out.print("继续?(y/n)");
   if(readString().toLowerCase().equals("n"))
    break;
  }
 }

 void copyVector(int[] v1, int[] v2) {
  for (int i = 0; i< v1.length; i++)
   v1[i] =v2[i];
 }

 void addVector(int[] v1, int[] v2) {
  for (int i = 0; i< v1.length; i++)
   v1[i] +=v2[i];
 }

 void subVector(int[] v1, int[] v2) {
  for (int i = 0; i< v1.length; i++)
   v1[i] -=v2[i];
 }

 boolean smallerVector(int[] v1, int[] v2){
  boolean value = true;
  for (int i = 0; i< v1.length; i++)
   if (v1[i]> v2[i]) {
    value= false;
    break;
   }
  return value;
 }

 boolean allEquals(boolean[] v, boolean b){
  boolean value = true;
  for (int i = 0; i< v.length; i++)
   if (v[i] !=b) {
    value= false;
    break;
   }
  return value;
 }

 boolean safeOrNot() {
  // 系统提供给进程继续运行所需的各类资源数目向量
  int work[] = newint[resourceType];
  // 系统是否有足够的资源分配给进程,使之运行完成
  boolean finished[] = newboolean[processCount];
  // Work := Available
  copyVector(work,available);
  while (true) {
   int i;
   for (i = 0; i< processCount; i++) {
    //1.Finish[i]=false 2.Ｎｅｅｄ［ｉ，ｊ］＜＝Ｗｏｒｋ［ｉ］
    if(!finished[i] &&smallerVector(need[i], work)) {
     //当进程Ｐ［ｉ］获得资源，可顺利执行，直至完成，并释放资源
     addVector(work,allocated[i]);
     finished[i]= true;
     break;
    }
   }

   //判断是否为安全序列
   if (i ==processCount)
    if(allEquals(finished, true))
     returntrue;
    else
     returnfalse;
  }
 }

 public String readString() {
  try {
   String s =br.readLine();
   if(echo)
    System.out.println(s);
   returns;
  } catch (Exception e) {
   System.out.println(e);
   returnnull;
  }
 }

 public int readInt() {
  try {
   String s =br.readLine();
   if(echo)
    System.out.println(s);
   returnInteger.parseInt(s);
  } catch (Exception e) {
   System.out.println(e);
   return0;
  }
 }

 public int[] readIntArray() {
  try {
   String s =br.readLine();
   if(echo)
    System.out.println(s);
   String tmp[]= s.split(" ");
   int value[] =new int[tmp.length];
   for (int i =0; i < value.length; i++)
    value[i]= Integer.parseInt(tmp[i]);
   returnvalue;
  } catch (Exception e) {
   System.out.println(e);
   returnnull;
  }
 }
}