关于银行家算法的讨论

关于对银行家算法的理解：

银行在借贷款给用户时会对用户进行评估，例如：原来借了多少钱，最大需求量等。银行方面在对于其他用户及自身条件进行安全性检查，看是否有一条安全序列能够保证银行不会亏空，并且能够合理分配已有资源；

类比到操作系统，在进程调度抢占资源时，难免会遇到资源不够分配，产生死锁问题。银行家算法对进程的需求进行从安全性分析，对资源进行预分配处理，如果存在安全序列，那么就按安全序列进行分配，这样是一定不会产生死锁的。

但是银行家算法需要获取进程的最大需求和已分配量，以及T0时刻需要请求的资源量，这无形之间加了很多的局限性。类比真实贷款，银行方面需要对用户进行更多方面的安全性分析，比如，还款能力等从而将风险降到最低。那么操作系统上针对这个算法能不能进行改善呢？这是对改进银行家算法的一个预测。

在对进程分配时的一个降低风险的分析，不能只从获取资源的数量开判断，而需要将更多的因素加入进来，例如进程的调用频率等。或者从寻找安全序列中下手，银行家算法中是对进程进行无序比较，只看是否符合条件。但是当进程数较多，又或者资源数较多时，这无疑又是非常复杂的。我们可以从横向比较一个线程的所有资源的需求转化成纵向比较单个线程对某个资源的需求，这样可以减少安全序列的判断时间。

以上便是我对银行家算法的一个分析。下面用java实现一个简单的银行家算法的例子

import java.util.Scanner;

public class Banker {
	int[] Available = {10, 8, 7};   //资源数
    int[][] Max = new int[3][3];    //最大需求
    int[][] Alloction = new int[3][3];  //分配
    int[][] Need = new int[3][3];      //需求
    int[][] Request = new int[3][3];   //存放请求
    int[] Work = new int[3];      //某时刻可分配值

    int num = 0;//进程编号
    Scanner in = new Scanner(System.in);

    /**
     * 设置各初始系统变量，并判断是否处于安全状态
     */
    public void setSystemVariable(){
        setMax();
        setAlloction();
        printSystemVariable();
        SecurityAlgorithm();
    }

    /**
     * 设置各进程最大需求
     */
    public void setMax() {
        System.out.println("请设置各进程的最大需求矩阵Max：");
        for (int i = 0; i < 3; i++) {
            System.out.println("请输入进程P" + i + "的最大资源需求量：");
            for (int j = 0; j < 3; j++) {
                Max[i][j] = in.nextInt();
            }
        }
    }
    /**
     * 设置已分配矩阵Alloction
     */
    public void setAlloction() {
        System.out.println("请设置请各进程分配矩阵Alloction：");
        for (int i = 0; i < 3; i++) {
            System.out.println("请输入进程P" + i + "的分配资源量：");
            for (int j = 0; j < 3; j++) {
                Alloction[i][j] = in.nextInt();
                
                Available[j] = Available[j] - Alloction[i][j];
                
                Need[i][j] = Max[i][j] - Alloction[i][j];
            }
        }
     
    }

    public void printSystemVariable(){
        System.out.println("此时资源分配量如下：");
        System.out.println("进程  "+"   Max   "+"   Alloction "+"    Need  "+"     Available ");
        for(int i=0;i<3;i++){
            System.out.print("P"+i+"  ");
            for(int j=0;j<3;j++){
               System.out.print(Max[i][j]+"  "); 
            }
            System.out.print("|  ");
            for(int j=0;j<3;j++){
               System.out.print(Alloction[i][j]+"  "); 
            }
            System.out.print("|  ");
            for(int j=0;j<3;j++){
               System.out.print(Need[i][j]+"  "); 
            }
            System.out.print("|  ");
            if(i==0){
                for(int j=0;j<3;j++){
                    System.out.print(Available[j]+"  ");
                }
            }
            System.out.println();
        }


    }

    /**
     * 设置请求资源量Request
     */
    public void setRequest() {

        System.out.println("请输入请求资源的进程编号：");
        num= in.nextInt();//设置全局变量进程编号num
        System.out.println("请输入请求各资源的数量：");
        for (int j = 0; j < 3; j++) {
            Request[num][j] = in.nextInt();
        }
        System.out.println("即进程P" + num + "对各资源请求Request：(" + Request[num][0] + "," + Request[num][1] + "," + Request[num][2] + ").");

        BankerAlgorithm();
    }

    public void BankerAlgorithm() {//银行家算法
        boolean T=true;

        if (Request[num][0] <= Need[num][0] && Request[num][1] <= Need[num][1] && Request[num][2] <= Need[num][2]) {//判断Request是否小于Need
            if (Request[num][0] <= Available[0] && Request[num][1] <= Available[1] && Request[num][2] <= Available[2]) {//判断Request是否小于Alloction
                for (int i = 0; i < 3; i++) {
                    Available[i] -= Request[num][i];
                    Alloction[num][i] += Request[num][i];
                    Need[num][i] -= Request[num][i];
                }

            } else {
                System.out.println("当前没有足够的资源可分配，进程P" + num + "需等待。");
               T=false;
            }
        } else {
            System.out.println("进程P" + num + "请求已经超出最大需求量Need.");
            T=false;
        }

       if(T==true){
        printSystemVariable(); 
        System.out.println("现在进入安全算法：");
        SecurityAlgorithm();
       }
    }


    /**
     * 检验是否有安全序列
     */
    public void SecurityAlgorithm() {
        boolean[] Finish = {false, false, false};//初始化Finish
        int count = 0;//完成进程数
        int circle=0;//循环圈数
        int[] S=new int[3];//安全序列
        for (int i = 0; i < 3; i++) {//设置工作向量
            Work[i] = Available[i];
        }
        boolean flag = true;
        while (count < 3) {
            if(flag){
                System.out.println("进程  "+"   Work  "+"   Alloction "+"    Need  "+"     Work+Alloction ");
                flag = false;
            }
            for (int i = 0; i < 3; i++) {

                if (Finish[i]==false&&Need[i][0]<=Work[0]&&Need[i][1]<=Work[1]&&Need[i][2]<=Work[2]) {//判断条件
                    System.out.print("P"+i+"  ");
                    for (int k = 0; k < 3; k++){
                        System.out.print(Work[k]+"  ");
                    }
                    System.out.print("|  ");
                    for (int j = 0; j<3;j++){
                    Work[j]+=Alloction[i][j];
                    }
                    Finish[i]=true;//当当前进程能满足时
                    S[count]=i;//设置当前序列排号

                    count++;//满足进程数加1
                    for(int j=0;j<3;j++){
                       System.out.print(Alloction[i][j]+"  "); 
                    }
                    System.out.print("|  ");
                    for(int j=0;j<3;j++){
                       System.out.print(Need[i][j]+"  "); 
                    }
                    System.out.print("|  ");
                    for(int j=0;j<3;j++){
                       System.out.print(Work[j]+"  "); 
                    }
                    System.out.println();
                }

            }
            circle++;//循环圈数加1

            if(count==3){//判断是否满足所有进程需要
                System.out.print("此时存在一个安全序列：");
                for (int i = 0; i<3;i++){//输出安全序列
                    System.out.print("P"+S[i]+" ");
                }
                System.out.println("故当前可分配！");
                break;//跳出循环
            }
            if(count<circle){//判断完成进程数是否小于循环圈数
                count=5;
                System.out.println("当前系统处于不安全状态，故不存在安全序列。");
                break;//跳出循环
            }
        }
    }

}