Java~操作系统实验银行家算法的实现(附带源码)

一、实验内容

银行家算法的实现。

二、实验目的

银行家算法是一种最有代表性的避免死锁的算法。在避免死锁方法中允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。通过编写一个模拟动态资源分配的银行家算法程序，帮助学生进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念，并掌握避免死锁的具体实施方法。

三、实验原理

3.1、银行家算法中的数据结构

1）可利用资源向量Available
是个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目。如果Available［j］=K，则表示系统中现有Rj类资源K个。

Resources[] Available = new Resources[resKindNum];//系统总资源

2）最大需求矩阵Max
这是一个n×m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。如果Max［i,j］=K，则表示进程i需要Rj类资源的最大数目为K。
3）分配矩阵Allocation
这也是一个n×m的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。如果Allocation［i,j］=K，则表示进程i当前已分得Rj类资源的数目为K。
4）需求矩阵Need。
这也是一个n×m的矩阵，用以表示每一个进程尚需的各类资源数。如果Need［i,j］=K，则表示进程i还需要Rj类资源K个，方能完成其任务。
Need［i,j］=Max［i,j］-Allocation［i,j］

//进程的数据结构
class PCB {
    public String name;
    public Resources[] max;//最大需求资源Max
    public Resources[] allocation;//已分配资源Allocation
    public Resources[] need;//需求资源Need
    public boolean finish = false;//表示进程是否获得足够资源

    public PCB(String name, Resources[] max, Resources[] allocation) {
        this.name = name;
        this.max = max;
        this.allocation = allocation;
        this.need = new Resources[max.length];
        for (int i = 0; i < need.length; i++) {
            this.need[i] = new Resources(max[i].name, max[i].num - allocation[i].num);
        }
    }

    @Override
    public String toString() {
        return this.name +(this.finish ? "进程已得到足够资源" : "需要等待");
    }
}

3.2、银行家算法

设Requesti是进程Pi的请求向量，如果Requesti［j］=K，表示进程Pi需要K个Rj类型的资源。当Pi发出资源请求后，系统按下述步骤进行检查：
(1)如果Requesti［j］≤Need［i,j］，便转向步骤(2)；否则认为出错，因为它所需要的资源数已超过它所宣布最大值。
(2)如果Requesti［j］≤Available［j］，便转向步骤(3)；否则，表示尚无足够资源，Pi须等待。

private boolean needWait(PCB pcb) {
        //挨个判断此时pcb这个进程所需要的每个资源,如果need大于系统当前可分配资源,就说明需要等待
        for (int i = 0; i < this.work.length; i++) {
            if (this.work[i].num < pcb.need[i].num) {
                return true;
            }
        }
        return false;
    }

(3)系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：
Available［j］=Available［j］-Requesti［j］;
Allocation［i,j］=Allocation［i,j］+Requesti［j］;
Need［i,j］=Need［i,j］-Requesti［j］;
系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。若安全，才正式将资源分配给进程Pi，以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。

 //进行资源分配
    public void resAllocation() {
        //对进程进行循环资源分配,当所有进程都需要等待或者所有进程都为安全状态退出循环
        for (int i = 0; !ifSafe() && !ifAllNeedWait(); i++) {
            //实现循环
            if (i == this.pcbs.length) {
                i = 0;
            }
            //判断当前这个进程是否已经获得过足够资源
            if (pcbs[i].finish) {
                continue;
            }
            //判断当前这个进程是否需要等待
            if (! needWait(pcbs[i])) {
                //进行资源分配
                mainOperation(pcbs[i]);
                System.out.println(pcbs[i]);
                System.out.println();
                displayWorks();
            }
        }
        System.out.println();
        if (ifSafe()) {
            System.out.println("系统处于安全状态");
        } else {
            System.out.println("系统处于不安全状态");
        }
    }

3.3、安全性算法

1）设置两个向量：
工作向量Work: 它表示系统可提供给进程继续运行所需的各类资源数目，它含有m个元素，在执行安全算法开始时，Work=Available;
工作向量Finish: 它表示系统是否有足够的资源分配给进程，使之运行完成。开始时先做Finish［i］=false; 当有足够资源分配给进程时， 再令Finish［i］=true。
2）从进程集合中找到一个能满足下述条件的进程： 
Finish［i］=false;
Need［i,j］≤Work［j］；若找到，执行 (3)，否则，执行 (4)
3）当进程Pi获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：
Work［j］=Work［i］+Allocation［i,j］;
Finish［i］=true;
go to step 2;

private void mainOperation(PCB pcb) {
        //运行到这说明该进程可以得到足够的资源,那么直接将该进程已分配的资源放回到系统中
        //并将finish改为true
        for (int i = 0; i < this.work.length; i++) {
            this.work[i].num += pcb.allocation[i].num;
            pcb.finish = true;
        }
    }

4）如果所有进程的Finish［i］=true都满足， 则表示系统处于安全状态；否则，系统处于不安全状态

四、实现代码

//系统资源的数据结构
class Resources {
    public String name;
    public int num;

    public Resources(String name, int num) {
        this.name = name;
        this.num = num;
    }

    @Override
    public String toString() {
        return "资源"+ name  + "有" + num;
    }
}
//进程的数据结构
class PCB {
    public String name;
    public Resources[] max;//最大需求资源Max
    public Resources[] allocation;//已分配资源Allocation
    public Resources[] need;//需求资源Need
    public boolean finish = false;//表示进程是否获得足够资源

    public PCB(String name, Resources[] max, Resources[] allocation) {
        this.name = name;
        this.max = max;
        this.allocation = allocation;
        this.need = new Resources[max.length];
        for (int i = 0; i < need.length; i++) {
            this.need[i] = new Resources(max[i].name, max[i].num - allocation[i].num);
        }
    }

    @Override
    public String toString() {
        return this.name +(this.finish ? "进程已得到足够资源" : "需要等待");
    }
}

public class BankerAlgorithm {
    private Resources[] work;//当前可以资源
    private PCB[] pcbs;//所有进程

    public BankerAlgorithm(Resources[] Available, PCB[] pcbs) {
        this.work = Available;//一开始可用资源与系统总资源是相同的
        this.pcbs = pcbs;
        //计算剩余可用资源
        actualWork();
    }

    private void actualWork() {
        for (int i = 0; i < this.work.length; i++) {
            //初始系统总资源减去已分配的资源就是当前可以利用的资源
            this.work[i].num = this.work[i].num - pcbsAllRes(i);
        }
    }
    //计算所有进程已分配的第i个资源总数
    private int pcbsAllRes(int index) {
        int sum = 0;
        for ( PCB p : pcbs
             ) {
            sum += p.allocation[index].num;
        }
        return sum;
    }

    //判断是否为安全状态
    private boolean ifSafe() {
        for (PCB p : pcbs
             ) {
            if (! p.finish) {
                return false;
            }
        }
        return true;
    }

    //进行资源分配
    public void resAllocation() {
        //对进程进行循环资源分配,当所有进程都需要等待或者所有进程都为安全状态退出循环
        for (int i = 0; !ifSafe() && !ifAllNeedWait(); i++) {
            //实现循环
            if (i == this.pcbs.length) {
                i = 0;
            }
            //判断当前这个进程是否已经获得过足够资源
            if (pcbs[i].finish) {
                continue;
            }
            //判断当前这个进程是否需要等待
            if (! needWait(pcbs[i])) {
                //进行资源分配
                mainOperation(pcbs[i]);
                System.out.println(pcbs[i]);
                System.out.println();
                displayWorks();
            }
        }
        System.out.println();
        if (ifSafe()) {
            System.out.println("系统处于安全状态");
        } else {
            System.out.println("系统处于不安全状态");
        }
    }

    private void displayWorks() {
        System.out.println("此时系统可用资源为:");
        System.out.println("====================");
        for (Resources r : this.work
             ) {
            System.out.println(r);
        }
        System.out.println("====================");
    }

    private boolean ifAllNeedWait() {
        for (PCB p : this.pcbs
             ) {
            //如果该进程已经得到过足够资源就不进行判断
            if (!p.finish) {
                //如果该进程不需要等待就直接返回false
                if (!needWait(p)) {
                    return false;
                }
            }
        }
        return true;
    }

    private void mainOperation(PCB pcb) {
        //运行到这说明该进程可以得到足够的资源,那么直接将该进程已分配的资源放回到系统中
        //并将finish改为true
        for (int i = 0; i < this.work.length; i++) {
            this.work[i].num += pcb.allocation[i].num;
            pcb.finish = true;
        }
    }

    private boolean needWait(PCB pcb) {
        //挨个判断此时pcb这个进程所需要的每个资源,如果need大于系统当前可分配资源,就说明需要等待
        for (int i = 0; i < this.work.length; i++) {
            if (this.work[i].num < pcb.need[i].num) {
                return true;
            }
        }
        return false;
    }
}

测试数据及结果

数据

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.print("输入资源有几种:");
        int resKindNum = scan.nextInt();
        Resources[] Available = new Resources[resKindNum];//系统总资源
        System.out.println();
        System.out.println("输入每个系统资源名称、系统资源数量");


        for (int i = 0; i < Available.length; i++) {
            System.out.println("初始化第" + (i +1) + "个资源");
            System.out.println();
            System.out.print("资源名称:");
            String name = scan.next();
            System.out.println();
            System.out.print("该资源数量:");
            int num = scan.nextInt();
            Available[i] = new Resources(name, num);
            System.out.println();
            System.out.println("第" + (i +1) + "个资源初始化完毕");
            System.out.println("====================");
        }


        System.out.println();
        System.out.println("系统资源初始化完毕,开始初始化进程");
        System.out.println();


        System.out.print("输入进程个数:");
        int pcbNums = scan.nextInt();
        PCB[] pcbs = new PCB[pcbNums];


        for (int i = 0; i < pcbNums; i++) {
            System.out.println("初始化第" + (i +1) + "个进程");
            System.out.println();
            System.out.print("输入进程名:");
            String name = scan.next();
            System.out.println();
            System.out.print("输入该进程最大需求资源:");
            Resources[] max = new Resources[resKindNum];
            int[] maxResNum = new int[resKindNum];
            for (int j = 0; j < resKindNum; j++) {
                maxResNum[j] = scan.nextInt();
            }


            for (int j = 0; j < max.length; j++) {

                max[j] = new Resources(Available[j].name, maxResNum[j]);
            }


            System.out.println();
            System.out.print("输入该进程已分配资源数目:");
            Resources[] allocation = new Resources[resKindNum];
            int[] allocReesNum = new int[resKindNum];
            for (int j = 0; j < resKindNum; j++) {
                allocReesNum[j] = scan.nextInt();
            }

            for (int j = 0; j < allocation.length; j++) {
                allocation[j] = new Resources(Available[j].name, allocReesNum[j]);
            }
            System.out.println();


            //此时一个进程的所有需要的东西都已输入完毕
            pcbs[i] = new PCB(name, max, allocation);
            System.out.println("第" + (i +1) + "个进程初始化完毕");
            System.out.println("====================");
        }

        System.out.println();
        System.out.println("========所有进程初始化完毕,开始资源分配========");
        System.out.println();

        boolean key = true;
        while (key) {
            BetterBankerAlgorithm bankerAlgorithm = new BetterBankerAlgorithm(Available, pcbs);
            bankerAlgorithm.resAllocation();
            System.out.println();
            System.out.println("是否需要再次申请资源输入: y or n ");
            char ch = scan.next().charAt(0);
            if (ch == 'n' || ch == 'N') {
                key = false;
            } else {
                System.out.print("输入要申请资源的进程名:");
                String name = scan.next();
                System.out.println();
                System.out.print("输入要申请资源的数量:");
                int[] res = new int[resKindNum];
                for (int i = 0; i < resKindNum; i++) {
                    res[i] = scan.nextInt();
                }
                System.out.println();


                for (PCB p : pcbs
                     ) {
                    p.finish = false;
                    if (p.name.equals(name)) {
                        for (int i = 0; i < p.allocation.length; i++) {
                            p.allocation[i].num += res[i];
                        }
                    }
                }
                System.out.println();
                System.out.println("========再次申请资源完毕,开始资源分配========");
                System.out.println();
            }
        }
    }
}

结果

输入资源有几种:4

输入每个系统资源名称、系统资源数量
初始化第1个资源

资源名称:R1

该资源数量:6

第1个资源初始化完毕
====================
初始化第2个资源

资源名称:R2

该资源数量:7

第2个资源初始化完毕
====================
初始化第3个资源

资源名称:R3

该资源数量:12

第3个资源初始化完毕
====================
初始化第4个资源

资源名称:R4

该资源数量:12

第4个资源初始化完毕
====================

系统资源初始化完毕,开始初始化进程

输入进程个数:5
初始化第1个进程

输入进程名:P0

输入该进程最大需求资源:0 0 1 2

输入该进程已分配资源数目:0 0 1 2

第1个进程初始化完毕
====================
初始化第2个进程

输入进程名:P1

输入该进程最大需求资源:2 7 5 0

输入该进程已分配资源数目:2 0 0 0

第2个进程初始化完毕
====================
初始化第3个进程

输入进程名:P2

输入该进程最大需求资源:6 6 5 6

输入该进程已分配资源数目:0 0 3 4

第3个进程初始化完毕
====================
初始化第4个进程

输入进程名:P3

输入该进程最大需求资源:4 3 5 6

输入该进程已分配资源数目:2 3 5 4

第4个进程初始化完毕
====================
初始化第5个进程

输入进程名:P4

输入该进程最大需求资源:0 6 5 2

输入该进程已分配资源数目:0 3 3 2

第5个进程初始化完毕
====================

========所有进程初始化完毕,开始资源分配========

P0进程已得到足够资源

此时系统可用资源为:
====================
资源R1有2
资源R2有1
资源R3有1
资源R4有2
====================
P3进程已得到足够资源

此时系统可用资源为:
====================
资源R1有4
资源R2有4
资源R3有6
资源R4有6
====================
P4进程已得到足够资源

此时系统可用资源为:
====================
资源R1有4
资源R2有7
资源R3有9
资源R4有8
====================
P1进程已得到足够资源

此时系统可用资源为:
====================
资源R1有6
资源R2有7
资源R3有9
资源R4有8
====================
P2进程已得到足够资源

此时系统可用资源为:
====================
资源R1有6
资源R2有7
资源R3有12
资源R4有12
====================

系统处于安全状态

是否需要再次申请资源输入: y or n 
Y
输入要申请资源的进程名:P2

输入要申请资源的数量:0 1 0 0


========再次申请资源完毕,开始资源分配========

P0进程已得到足够资源

此时系统可用资源为:
====================
资源R1有2
资源R2有0
资源R3有1
资源R4有2
====================
P3进程已得到足够资源

此时系统可用资源为:
====================
资源R1有4
资源R2有3
资源R3有6
资源R4有6
====================
P4进程已得到足够资源

此时系统可用资源为:
====================
资源R1有4
资源R2有6
资源R3有9
资源R4有8
====================

系统处于不安全状态

是否需要再次申请资源输入: y or n 
N