银行家安全性算法实现（java）

import java.util.Vector;
import java.util.function.DoubleToIntFunction;

public class BankerClass {
    int []resource = {10, 5, 7};
    int available[] = {3, 3, 2};
    int work[];
    int allow[][] = {{0, 1, 0}, {2, 0, 0}, {3, 0, 2}, {2, 1, 1}, {0, 0, 2}};//已经占有的资源数
    int need[][] = {{7, 4, 3}, {1, 2, 2}, {6, 0, 0}, {0, 1, 1}, {4, 3, 1}};//还需要的资源数
    int maxx[][] = {{7, 5, 3}, {3, 2, 2}, {9, 0, 2}, {2, 2, 3}, {4, 3, 3}};//最大占有资源数

    int n = 5;           //进程数
    int m = 3;           //资源数
    boolean[] finish  = new boolean[5];
    int sum = 0;
    Vector<Integer> res = new Vector<>();

    void ifSafe(){
        //1.i j k 分别i个安全序列 j为从进程中选一个 k个种类资源
        //获取i个安全序列
        int i,j,k;
        for ( i = 0; i < n; i++) {//多少个进程多少个安全序列
            for ( j = 0; j < n; j++) {
                //1 获取一个进程
                boolean isE = true;
                if (finish[j]){
                    continue;//该进程已经进入安全序列
                }
                for ( k = 0; k < m; k++) {//判断所有的资源数是否够用
                    if (work[k]<need[j][k]){
                        isE=false;
                        break;
                    }
                }
                if (isE){//所有资源数够用
                    res.add(j);
                    finish[j]=isE;
                    for ( k = 0; k < m; k++) {
                        work[k]+=need[j][k];
                    }
                    break;
                }

            }
            if (j>=n){//遍历结束 此时可能安全 也可能不安全 看vector中的安全序列数量
                break;
            }

        }
        if (i>=n){//安全序列找完了
            for (int l = 0; l < res.size(); l++) {
                System.out.print("P"+res.get(l)+" ");//输出安全序列
            }
            sum++;//用于标记是否安全
        }
    }
    void request(int p,int req[]){//p为进程序号 req[]为请求向量
        //1。检验请求向量是否大于需求
        int i;
        boolean isE=true;
        for (i  = 0; i < m; i++) {
            if (need[p][i]<req[i]){//某个资源数需求大于need数组
                isE=false;
                break;
            }
        }
        if (!isE) {
            System.out.println("请求异常");
            return;
        }
        for ( i = 0; i < m; i++) {
            if (available[i]<req[i]){//大于资源可用池
                isE=false;
                break;
            }
        }
        if (isE){
            System.out.println("资源不足请等待");
            return;
        }
        for (i=0;i<m;i++){
            work[i]=available[i]-req[i];
            need[p][i]-=req[i];
            allow[p][i]+=req[i];
        }
        ifSafe();
        if (sum>0){
            System.out.println("可以分配资源");
        }else {
            System.out.println("无法分配资源");
        }
    }
}

须知：
allow矩阵为各进程目前所占有的资源数
need矩阵为各进程还需要多少资源
max为各进城总共能拥有的资源数
总流程为：
1.输入请求进程序号和请求资源向量
2.检测可用资源是否足够
3.检测是否超出need矩阵
4.设置work数组为剩余可用资源数组=可用数组-请求向量
5.减去需求矩阵
6.增加已用矩阵
7.进去安全检查

安全性检查为获取n个进程的安全序列
每次都遍历n个进程获取一个序列
检查所有资源是否足够
work是否满足该进程的need
满足返回need的资源到work中