计算机操作系统_银行家算法（java实现）

计算机操作系统_银行家算法（java实现）

银行家算法介绍（原书内容）

*** 计算机操作系统/汤小丹等编著.-4版.-西安:西安电子科技大学出版社,页数：P120–P123 * **

什么是银行家算法?
　　银行家算法（Banker’s Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。
　　在银行中，客户申请贷款的数量是有限的，每个客户在第一次申请贷款时要声明完成该项目所需的最大资金量，在满足所有贷款要求时，客户应及时归还。银行家在客户申请的贷款数量不超过自己拥有的最大值时，都应尽量满足客户的需要。在这样的描述中，银行家就好比操作系统，资金就是资源，客户就相当于要申请资源的进程。
　　银行家算法是一种最有代表性的避免死锁的算法。在避免死锁方法中允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。为实现银行家算法，系统必须设置若干数据结构。
　　
银行家算法中的数据结构
　　为了实现银行家算法，在系统中必须设置这样四个数据结构，分别用来描述系统中可利用的资源、所有进程对资源的最大需求、系统中的资源分配，以及所有进程还需要多少资源的情况。
　　(1) 可利用资源向量 Available。这是一个含有 m 个元素的数组，其中的每一个元素代表一类可利用的资源数目，其初始值是系统中所配置的该类全部可用资源的数目，其数值随该类资源的分配和回收而动态地改变。如果 Available[j] = K，则表示系统中现Rj类资源K个。
　　(2) 最大需求矩阵Max。这是一个n x m的矩阵，它定义了系统中n个进程中的每个进程对m类资源的最大需求。如果Max[i,j] = K，则表示进程i需要Rj 类资源的最大数目为K。
　　(3) 分配矩阵 Allocation。这也是一个n x m的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。如果 Allocation[i,jl = K，则表示进程i当前己分得Rj类资源的数目为K。
　　(4) 需求矩阵Need.这也是一个n×m的矩阵，用以表示每一个进程尚需的各类资源数。如果Need[i,j] = K，则表示进程i还需要Rj类资源K个方能完成其任务。
上述三个矩阵间存在下述关系:
　　　　　　　　　　　　　　Need[i,j] = Max[i,j] - allocation[i, j]
　　　　　　　　　　　　　　
银行家算法详述：
　　设 Request；是进程Pi的请求向量，如果 Requesti[j] = K，表示进程Pi需要K个Rj类型的资源。当Pi发出资源请求后，系统按下述步骤进行检査:
　　(1) 如果 Requesti[j] ≤ Need[i,j]便转向步骤(2)；否则认为出错，因为它所需要的资源数已超过它所宣布的最大值。
　　(2) 如果 Requesti[j] ≤ Available[j]，便转向步骤(3)；否则，表示尚无足够资源，Pi须等待。
　　(3) 系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值
　　　　Available[j] = Available[j] - Requesti[j];
　　　　Allocation[i,j] = Allocation[i,j] + Requesti[j];
　　　　Need[i,j] = Need[i,j] - Requesti[j];
　　(4) 系统执行安全性算法，检查此次资源分配后系统是否处于安全状态。若安全，才正式将资源分配给进程Pi，以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。
　　
安全性算法:
系统所执行的安全性算法可描述如下:
　　(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[j] + Allocation[i,j];
　　　　Finish[i] = true;
　　　　go to step 2;(goto语句不推荐使用 _ )
　　(4)如果所有进程的 Finish[i] =true都满足，则表示系统处于安全状态；否则，系统处于不安全状态。

java实现代码

import java.util.Scanner;

/**
 * 
 * @author   广工——欧神仙
 *
 **/
public class main {

    int j; //进程的数量
    int a; //资源的种类数
    int[] Available; //各资源还可以用利用的数量
    int[][] Max;   // 某进程能分配某类资源的最大数目
    int[][] Allocation; // 某进程已经分配了某类资源的数量
    int[][] Need;   // 某进程还需要分配某类资源的数量
    boolean[] Finish; //用于判断进程能否成功分配资源
    int n;  // 请求分配的进程号
    int[] Request; //进程请求某类资源的数量

    //初始化函数
    public void init() {
        System.out.print("输入进程的数目：");
        Scanner scanner01 = new Scanner(System.in);
         j = scanner01.nextInt();  //进程的数量

        System.out.print("输入资源的种类数目：");
         a =  scanner01.nextInt();  //资源的种类数

       Available = new int[a]; //各资源还可以用利用的数量
        for (int i = 0; i < a; i++) {
            System.out.print("输入第"+(i+1)+"资源可以用的数量：");
            Available[i] = scanner01.nextInt();
        }
         Max = new int[j][a];  // 进程j能分配a类资源的最大数目
        for (int i = 0; i < j; i++) {
            for (int k = 0; k < a; k++) {
                System.out.print("输入进程P"+i+"能分配第"+(k+1)+"类资源的最大数目：");
                Max[i][k] = scanner01.nextInt();
            }
        }

       Allocation = new int[j][a]; // 进程j已分配a类资源的数目
        for (int i = 0; i < j; i++) {
            for (int k = 0; k < a; k++) {
                System.out.print("输入进程P"+i+"已分配第"+(k+1)+"类资源的数目：");
                Allocation[i][k] = scanner01.nextInt();
            }
        }

        Need = new int[j][a];   //进程j还需要a类资源的数目
        for (int i = 0; i < j; i++) {
            for (int k = 0; k < a; k++) {
                System.out.print("输入进程P"+i+"还要分配第"+(k+1)+"类资源的数目：");
                Need[i][k] = scanner01.nextInt();
            }
        }

       show();  //显示系统各进程资源的分配情况，用课本的表那样显示

    }

    //显示系统各进程资源的分配情况，用课本的表那样显示
    public void show() {
        System.out.print("进程  \t" + "MAX｜\t" + "Allocation｜\t" + "Need｜\t" + "Available\t");
        System.out.println("");
        for (int i = 0; i < j; i++) {
            System.out.print("P" + i + "\t");
            for (int k = 0; k < a; k++) {
                System.out.print(Max[i][k] + " ");
            }
            System.out.print("｜\t");
            for (int k = 0; k < a; k++) {
                System.out.print(Allocation[i][k] + " ");
            }
            System.out.print("｜\t");
            for (int k = 0; k < a; k++) {
                System.out.print(Need[i][k] + " ");
            }
            System.out.print("｜\t");
            for (int k = 0; k < a; k++) {
                if (i == 0) {
                    System.out.print(Available[k] + " ");
                }
            }
            System.out.println("");
        }
    }

    //判断系统是否安全
    public boolean safety_check(){

        int b=0;
        int c=j;

        Finish = new boolean[j];
        for (int i = 0; i < j; i++) {
            Finish[i] = false;
        }

        int[] work = new int[a];
        for (int i = 0; i < a; i++) {
            work[i] =Available[i];
        }

        //关键判定是否有安全序列的算法
      while(c!=0){
          int e=0;
          for (int i = 0; i < j; i++) {
              b = 0;
              if(!Finish[i]){
                  for (int k = 0; k < a; k++) {
                      if(Need[i][k] <= work[k]){
                          b++;
                      }
                      if(b==a){
                          for (int z = 0; z < a; z++) {
                              work[z] = work[z] + Allocation[i][z];
                          }
                          Finish[i] = true;
                          e++;
                          c--;
                          if(c==0){
                              System.out.print("P"+i);
                          }else{
                              System.out.print("P"+i+"->");
                          }
                      }
                  }
              }
          }
          if(c==j || e==0){
              return false;
          }
      }
        return true;
    }

    //进程申请请求资源的处理
    public boolean apply_request(){
        System.out.print("输入你要请求资源的进程：P");
        Scanner scanner = new Scanner(System.in);
         n = scanner.nextInt();
         Request = new int[a];
        for (int i = 0; i < a; i++) {
            System.out.print("输入第"+(i+1)+"资源的请求数量：");
             Request[i] = scanner.nextInt();
             if(Request[i]>Available[i] || Request[i] > Need[n][i]){
                 return false;
             }
        }
        for (int i = 0; i < a; i++) {
            Allocation[n][i] = Allocation[n][i] + Request[i];
            Need[n][i] = Need[n][i] - Request[i];
            Available[i] = Available[i] - Request[i];
        }
        show();
        return true;
    }

    //主函数，程序入口
    public static void main(String[] args) {

       main m = new main();
       m.init();      //初始化系统
       int control;  //控制是否继续进行进程申请的请求
        System.out.println("进行进程资源请求分配请输入1，退出请输入2。");
        Scanner co = new Scanner(System.in);
        control = co.nextInt();
       while(control==1){
           if(m.apply_request()){
               System.out.println("检查系统的安全性：");
               if(m.safety_check()){
                   System.out.println("   系统处于安全状态，可分配！");
               }else{
                   System.out.println(" 分配资源后，系统会进入不安全状态，此时系统不分配该进程这样的资源数，需要等待！");
                   //不安全，要返回之前的资源分配情况
                   for (int i = 0; i < m.a; i++) {
                       m.Allocation[m.n][i] = m.Allocation[m.n][i] - m.Request[i];
                       m.Need[m.n][i] = m.Need[m.n][i] + m.Request[i];
                       m.Available[i] = m.Available[i] + m.Request[i];
                   }
               }
           }else{
               System.out.println("资源请求数量超出了可利用的资源数量! 需要等待！");
           }
           System.out.println("进行进程资源请求分配请输入1，退出请输入2！");
           control = co.nextInt();
       }
    }
}

程序运行结果

*** 参考文献：计算机操作系统/汤小丹等编著.-4版.-西安:西安电子科技大学出版社,页数：P120–P123 **

P123 （5）答：若P0发出请求为Request0（2，1，0），系统将是安全的，有一安全序列 : P1->P3->P4->P0->P2

这是我第一篇csdn，如果能帮助到你的，记得一键三连哦^_，谢谢支持。

有问题，可以在评论里问我；有错误的地方，欢迎指正！