操作系统 之 银行家算法 （java）

实验：
银行家算法是避免死锁的一种重要方法，能够有效的在资源分配的过程中，对系统的安全性进行检测。

通过银行家算法设计与实现，可以加深对死锁的理解，掌握死锁的预防、避免、检测和解除的基本原理，重点掌握死锁的避免方法—银行家算法。初步具有研究、设计、编制和调试操作系统模块的能力。

实验目的：
使用编程语言实现防止死锁的银行家算法，至少实现：
实现动态进程的输入
能够判断进程之间能否无死锁的运行下去，以及安全序列
当各个进程又提出新的申请，资源是否能满足
界面美观。
撰写课程设计报告

实验代码：

package 实验二;
import java.util.Arrays;
import java.util.Scanner;
public class Banker {
    static int Can_assigned;
    static process[]  processS=new process[0];
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        System.out.println("请输入可分配资源");
        Can_assigned=in.nextInt();
        int n=-1;
        while (n!=0){
            System.out.println("请输入选择  1:添加  2:输出  3:分配  0 退出");
            n= in.nextInt();
            switch (n){
                case 0:
                    break;
                case 1:
                    add();
                    break;
                case 2:
                    printprocess();
                    break;
                case 3:
                    assignment();
                    break;
                default:
                    System.out.println("无效输入");
            }
        }
    }
    private static void assignment() {
        printprocess();
        Scanner in=new Scanner(System.in);
        System.out.println("请输入选择要分配资源的进程");
        int n= in.nextInt();
        System.out.println("请输入选择要分配的资源数");
        int J= in.nextInt();
        if(J>=processS[n-1].NoCompleted){
            System.out.println("已分配资源");
            Can_assigned+=processS[n-1].Completed;
            processS[n-1].Completed=processS[n-1].all;
            processS[n-1].NoCompleted=0;
            return;
        }
        int Can_assigned1=Can_assigned;
        if(Can_assigned1>=J){
            Can_assigned1-=J;
        }else {
            System.out.println("没有这么多资源请重新输入");
            assignment();
        }
        if(isok(Can_assigned1,n-1,J)){
            System.out.println("资源已分配");
            Can_assigned-=J;
        }else {
            System.out.println("会产生阻塞资源 分配失败");
        }
    }
    private static boolean isok(int can_assigned1, int n, int j) {
        int [] ok=new int[processS.length];
        processS[n].NoCompleted-=j;
        processS[n].Completed+=j;
        for (int i = 0; i <processS.length ; i++) {
            for (int k = 0; k <processS.length ; k++) {
                if (ok[k]==0){
                    if (can_assigned1>=processS[k].NoCompleted){
                        ok[k]=1;
                        can_assigned1+=processS[k].all;
                    }
                }
            }
        }
        for (int i:ok){
            if (i==0){
                processS[n].NoCompleted+=j;
                processS[n].Completed-=j;
                return false;
            }
        }
        return true;
    }
    private static void printprocess() {
        System.out.println("进程名     已完成资源     未完成资源");
        for (process i:processS){
            System.out.println(i.processname+"         "+i.Completed+"           "+i.NoCompleted+"    ");
        }
        System.out.println("剩余可分配资源："+ Can_assigned);
    }
    private static process[] add() {
        Scanner in=new Scanner(System.in);
        System.out.println("请输入已完成资源");
        int Completed=in.nextInt();
        System.out.println("请输入未完成资源");
        int NoCompleted=in.nextInt();
        processS=Arrays.copyOf(processS,processS.length+1);
        processS[processS.length-1]=new process(Completed,NoCompleted);
        return processS;
    }
}
class process {
    static int name=1;
    int Completed;//已完成
    int NoCompleted;//未完成
    int all;//全部
    String processname;
    public process(int completed, int noCompleted) {
        Completed = completed;
        NoCompleted = noCompleted;
        all=completed+noCompleted;
        processname="进程"+name++;
    }
}

实验结果

上一篇操作系统之 调度算法（java）
下一篇操作系统之动态分区分配算法 （java）

代码 如果直接分配完 的 话 会有一丢丢问题 不过问题不大 可供参考
如果本文章对你有用 记得点赞哦 (￣∇￣)