银行家算法（操作系统 Java版）

Posted 2022-05-09 Huterox

文章目录

• 前言
• 数据结构
• 实现
• 效果

前言

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

数据结构

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

主要是我这里的几个数据结构

就这几个，含义的话和操作系统书上的一样。
整体实现也很简单，就是几个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();
    

效果