操作系统 银行家算法

【问题阐述】

数据结构

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

安全性检查算法

• (1)设置两个工作向量Work=AVAILABLE;FINISH
• (2)从进程集合中找到一个满足下述条件的进程， FINISH==false; NEED<=Work; 如找到，执行（3)；否则，执行（4)
• (3)设进程获得资源，可顺利执行，直至完成，从而释放资源。 Work=Work+ALLOCATION; Finish=true; GOTO
  2
• (4)如所有的进程Finish= true，则表示安全；否则系统不安全。

【详细代码】

package banker;import java.util.Scanner;public class BankerMath {      static int available[]=new int[3];         //资源数      static int max[][]=new int[5][3];          //最大需求      static int allocation[][]=new int[5][3];   //分配      static int need[][]=new int[5][3];         //需求      static int request[]=new int[3];           //存放请求      Scanner scanner=new Scanner(System.in);      int thread;  //线程号      //初始化      public void getResources(){          System.out.println("请输入A,B,C三类资源的数目：");          //输入A,B,C三类资源数量          for(int i=0;i<3;i++){              available[i]=scanner.nextInt();          }          //输入进程对三类资源的最大需求          for(int i=0;i<5;i++){              System.out.println("请输入进程"+i+"对A,B,C三类资源的最大需求");              for(int j=0;j<3;j++){                  max[i][j]=scanner.nextInt();              }          }          //输入进程分配的三类资源数          for(int i=0;i<5;i++){              System.out.println("请输入进程"+i+"已分配的A,B,C三类资源数");              for(int j=0;j<3;j++){                  allocation[i][j]=scanner.nextInt();              }          }          //计算进程还需要的三类资源数          for(int i=0;i<5;i++){              for(int j=0;j<3;j++){                  need[i][j]=max[i][j]-allocation[i][j];              }          }          //重新计算available          for(int i=0;i<3;i++){              for(int j=0;j<5;j++){                  available[i]-=allocation[j][i];              }          }      }      //用户输入要申请资源的线程和申请的资源，并进行判断      public void getThread(){          System.out.println("请输入申请资源的线程");          int thread=scanner.nextInt();     //线程          if(thread<0||thread>4){              System.out.println("该线程不存在,请重新输入");              getThread();          }else{              this.thread=thread;              System.out.println("请输入申请的资源(三种，若某种资源不申请则填0)");              for(int i=0;i<3;i++){                  request[i]=scanner.nextInt();              }              if(request[0]>need[thread][0]||request[1]>need[thread][1]||request[2]>need[thread][2]){                  System.out.println(thread+"线程申请的资源超出其需要的资源，请重新输入");                  getThread();              }else{                  if(request[0]> available[0]||request[1]> available[1]||request[2]> available[2]){                      System.out.println(thread+"线程申请的资源大于系统资源，请重新输入");                      getThread();                  }              }              changeResources(thread);              if(check(thread)){                   getThread();              }else{                  recoverResources(thread);                  getThread();              }          }      }       //thread线程请求响应后，试探性分配资源       public void changeResources(int thread){           for(int i=0;i<3;i++){               //重新调整系统资源数               available[i]-=request[i];               //计算各个线程拥有资源               allocation[thread][i]+=request[i];               //重新计算需求               need[thread][i]-=request[i];           }            }         //安全性检查为通过，分配失败时调用，恢复系统原状                   public void recoverResources(int thread){             for(int i=0;i<3;i++){                   //重新调整系统资源数                   available[i]+=request[i];                   //计算各个线程拥有资源                   allocation[thread][i]-=request[i];                   //重新计算需求                   need[thread][i]+=request[i];            }           }      //对线程thread安全性检查       public boolean check(int thread){           boolean finish[]=new boolean[5];           int work[]=new int[3];           int queue[]=new int[5];   //由于存放安全队列           int k=0;//安全队列下标           int j;  //要判断的线程           int i;           //是否分配的标志           for(i=0;i<5;i++)               finish[i]=false;           j=thread;           for(i=0;i<3;i++){               work[i]=available[i];           }           while(j<5){               for( i=0;i<3;i++){                     if(finish[j]){                       j++;                       break;                   }else if(need[j][i]>work[i]){                       //System.out.println(need[j][i]+"*"+i+work[i]);                       j++;                       break;                   }else if(i==2){                       for(int m=0;m<3;m++){                           work[m]+=allocation[j][m];                       }                       finish[j]=true;                       queue[k]=j;                       k++;                       j=0;   //从最小线程再开始判断                   }               }           }           //判断是否都属于安全状态           for(int p=0;p<5;p++){               if(finish[p]=false){                   System.out.println("系统不安全，资源申请失败");                   return false;               }           }           System.out.println("资源申请成功，安全队列为：");           for(int q=0;q<5;q++){               System.out.println(queue[q]);           }            return true;       }       //打印need和available，需要时调用        public void showResources(){            System.out.println("need");            for(int i=0;i<5;i++){                for(int j=0;j<3;j++){                    System.out.print(need[i][j]+"     ");                }            }               System.out.println("available");                for(int j=0;j<3;j++){                    System.out.print(available[j]+"     ");                }        }     public static void main(String[] args) {        BankerMath bk=new BankerMath();        bk.getResources();        bk.getThread();      }  }