前言

这个就没啥了，俺是来水博文的~

数据结构

这个银行家算法的原理很简单，我这里就不说了，代码有注释的。

主要是我这里的几个数据结构 就这几个，含义的话和操作系统书上的一样。 整体实现也很简单，就是几个for循环的事情。

实现

import java.util.ArrayList;

public class 银行家算法 {

    //我们假设有5个进程p0,1,2,3,4
    //有三个资源A，B，C 10 5 7

    static int[] Resource={10,5,7};
    static int[][] Claim;
    static int[][] Allocation;
    static int[][] Need;
    static int[] Available;
    static boolean[] Used;

    static ArrayList<Integer> Order = new ArrayList<>();

    public static void Init(){
        //这是一个初始化方法，负责模拟我们的初始化情况
        //我们还是来个最直接方法吧
        Claim=new int[][]{{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};
        Allocation = new int[][]{{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};
        Need = new int[5][3];
        ComNeed();
        Available = new int[3];
        ComAvailable();
        Used = new boolean[5];
    }

    public static void ComAvailable(){
        //计算剩下多少个东西
        int[] count = new int[3];
        for (int i = 0; i < Allocation.length; i++) {
            for (int j = 0; j < Allocation[i].length; j++) {
                count[j]+=Allocation[i][j];
            }
        }
        for (int i = 0; i < Resource.length; i++) {
            Available[i] = Resource[i]-count[i];
        }
    }

    public static void ComNeed(){
        //计算需要的那个Need
        for(int i=0;i<Claim.length;i++){
            for(int j=0;j<Claim[i].length;j++){
                Need[i][j] = Claim[i][j] - Allocation[i][j];
            }
        }
    }

    public static void show(){
        //这个是负责显示我们模拟的这个情况
        System.out.println(Order.toString());
    }
    public static int find(){
        int index = -1;
        //负责找到可以给资源的那个进程对应的下标



        for (int i = 0; i < Need.length; i++) {
            boolean flag = true;
            for (int j = 0; j < Need[i].length; j++) {
                if(Used[i]) continue;
                if(Need[i][j]>Available[j]){
                    flag=false;
                    break;
                }
                if(flag){
                    index = i;
                    return index;
                }
            }
        }

        return index;
    }

    public static void addAvailable(int index){
        for (int i = 0; i < Available.length; i++) {
            Available[i] += Need[index][i];
        }
    }
    public static void update(){
        //负责更新
        while (true){
            int ok_run = find();
            if(ok_run!=-1){
                Used[ok_run] = true;
                Order.add(ok_run);
                addAvailable(ok_run);
                if(Order.size()==5){
                    System.out.println("执行完毕");
                    show();
                    return;
                }
            }else {
                System.out.println("无法分配");
                show();
                return;
            }
        }
    }

    public static void main(String[] args) {
        Init();
        update();
    }

}

效果