操作系统的银行家算法

public class Banker {
   /*
    * Avaliable[] Avaliable[i] = k 表示系统中i类资源可分配(现有)的数目为k ,
    * Max[][] Max[i][j] = k 表示进程i需要j类资源的最大数目为k
    * Allocation [][] Allocation[i][j] = k 代表当前系统已经分配给i进程j类资源为k
    * Need[][] Need[i][j] = k 表示i进程还需要j类资源为k
    * 关系 need[i][j] = max[i][j] - Allocation[i][j]
    **/
   // 安全性问题 工作向量Work 表示系统可提供给进程继续运行的各类资源数目 含有m个元素，在执行安全算法开始时
   // Work = Avaliable;
   // Finish 表示系统是否有足够的资源分配给进程 使之运行完成 先令Finish[i] = false；当有足够的资源分配给进程时，
   // 令Finish = true;
   // 从进程集合中找到一个能满足下述条件的进程
   // 1.Finish = false;
   // 2.Need[i][j] <= Work[j]

    // 系统可用的资源 这里有三类资源
    int[] available = {10,8,7};
    // 各进程需要各资源的最大值 三个进程每个资源的占用
    // [4][2][3]  第一个进程需要三类资源分布为4、2、3
    // [4][5][6]  依次类推
    // [3][2][1]
    int[][] max = {{4,2,3},{4,5,6},{3,2,1}};
    // 各进程的各资源已分配情况 三个进程每个资源的分配
    // [2][1][2]
    // [2][3][3]
    // [1][2][1]
    int[][] alloction = {{2,1,2},{2,3,3},{1,2,1}};
    // 各进程对各进程的需求
    // [2][1][1]
    // [2][2][3]
    // [2][0][0]
    int[][] need = {{2,1,1},{2,2,3},{2,0,0}};
    // 各进程对各资源的请求
    // [2][1][1]
    // [2][2][3]
    // [2][0][0]
    int[][] request = {{2,1,1},{2,2,3},{2,0,0}};
    // 用于安全算法内的系统剩余资源
    int[] work = new int[3];

    int num = 0; // 进程编号

    Scanner in = new Scanner(System.in);
    
    private void BankerAlgorithm() { //银行家算法
        boolean t = true;
        if (request[num][0] <= need[num][0] && request[num][1] <= need[num][1] && request[num][2] <= need[num][3]) {
            //请求的 要比需要的少才行
            if (request[num][0] <= available[0] && request[num][1] <= available[1] && request[num][2] <= available[2]) { // 判断资源够不够分配
                for (int i = 0; i < 3; i++) {
                    available[i] -= request[num][i];
                    alloction[num][i] += request[num][i];
                    need[num][i] -= request[num][i];
                }
            } else {
                System.out.println("当前没有足够的资源可以进行分配");
                t = false;
            }
        } else {
            System.out.println("进程P" + num + "请求已经超出最大需求量Need.");
            t=false;
        }

        if (t == true) {
            securityAlgorithm(); // 安全监测 
        }
    }

    private void securityAlgorithm() {
        boolean[] finish = {false,false,false};// 初始化 finish
        int count = 0; // 完成的进程数
        int circle = 0; // 循环圈数
        int[] s = new int[3];// 安全序列
        for (int i = 0; i < 3; i++) { // 设置工作向量
            work[i] = available[i];
        }
        boolean flag = true;

        while(count < 3) {

            if (flag) {
                System.out.println("进程" + "work" + "alloction" + "need" + "work + alloction");
                flag = false;
            }
            for (int i = 0; i < 3; i++) {

                if (finish[i] == false && need[i][0] <= work[0] && need[i][1] <= work[1] && need[i][2] <= work[2]) {
                    //判断条件
                    System.out.print("P"+i+"  ");
                    for (int k = 0; k < 3; k++){
                        System.out.print(work[k]+"  ");
                    }
                    System.out.print("|  ");
                    for (int j = 0; j < 3;j++){
                        work[j] += alloction[i][j]; // 把资源放开吧
                    }
                    finish[i] = true;//当当前进程能满足时
                    s[count] = i;//设置当前序列排号

                    count++;//满足进程数加1
                    for(int j = 0; j < 3; j++){
                        System.out.print(alloction[i][j]+"  ");
                    }
                    System.out.print("|  ");
                    for(int j = 0;j < 3;j++){
                        System.out.print(need[i][j]+"  ");
                    }
                    System.out.print("|  ");
                    for(int j = 0;j < 3;j++){
                        System.out.print(work[j] + "  ");
                    }
                    System.out.println();
                }
            }

            circle++;//循环圈数加1
            if(count == 3){//判断是否满足所有进程需要
                System.out.print("此时存在一个安全序列：");
                for (int i = 0; i < 3;i++){//输出安全序列
                    System.out.print("P"+s[i]+" ");
                }
                System.out.println("故当前可分配！");
                break;//跳出循环
            }
            if(count < circle){//判断完成进程数是否小于循环圈数
                count = 5;
                System.out.println("系统处于不安全状态");
                break;//跳出循环
            }
          }
       }
    }