操作系统 银行家算法

【问题阐述】

数据结构

• 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();  

    }  

}