银行家算法代码,Java代码库,德仔网

代码语言
代码分类
【Java】银行家算法
作者:我是it爱好者 / 发布于2013/12/26/ 581
操作系统java实现银行家算法，可以动态分配，持续分配，回收资源，无错误
import java.util.Scanner;

import javax.swing.JOptionPane;
         /****************定义变量与数组*******************/
 public class ThefBanker {
  int m; //进程个数
  int n; //每个进程的资源个数
  int[][] max; //最大需求矩阵
  int[][] allocation; // 已分配的资源（已占有的资源）
  int[][] need;  // 需求的资源
  int[] available;  // 可利用的资源
  int[] p;  // 记录安全序列
  boolean[] finish; // 系统是否有足够的资源分配给进程？true 表示可以 false 表示不可以
  Scanner input = new Scanner(System.in);
  
  /************************** 初始化进程和各类资源数************************/
  public ThefBanker() { 
     System.out.println("请输入系统中的【进程数】:");
     m = input.nextInt();
     System.out.println("请输入进程的【资源类型数】:");
     n = input.nextInt();
     max = new int[m][n];
     allocation = new int[m][n];
     need = new int[m][n];
     available = new int[n];
     finish = new boolean[m];
    
     System.out.println("请输入一个"+m+"行"+n+"列的各进程的最大需求量：");
     for (int i=0;i<max.length;i++) { //依次输入进程的各个最大资源数
     System.out.println("请输入第p("+i+")进程的Max：");
      for(int j=0;j<max[i].length;j++){
       max[i][j] = input.nextInt();
      }
     }
     System.out.println("请输入一个"+m+"行"+n+"列的各资源数量：");
     for (int i=0;i<allocation.length;i++) { //依次输入进程的各个占有资源数
     System.out.println("请输入第p("+i+")进程中的Alloction：");
      for (int j=0;j<allocation[i].length;j++) {
       allocation[i][j] = input.nextInt();
      }
     }
     for (int i=0;i<need.length;i++) { //计算出各个进程需求的资源数
      for(int j=0;j<need[i].length;j++){
       need[i][j] = max[i][j] - allocation[i][j];
      }
     }
     System.out.println("请输入可用资源数Avallable："); //输入进程的可用资源数
     for (int i=0;i<n;i++) {
      available[i] = input.nextInt();
     }
     System.out.println("初始化结果为下表：");
     print();
  }
  
  /******************显示资源分配情况********************/
    public void print() {
     System.out.println("-----------------------资源分配情况-----------------------------");
     System.out.println("\tMax\tAllocation\tNeed\tAvalable");
    // System.out.println("\tA B C\tA B C\t\tA B C\tA B C");
     for (int i=0;i<m;i++) {
      System.out.print("P("+i+"): ");
      System.out.print(" ");
       for (int j=0;j<n;j++) {
        if(max[i][j]>9){
         System.out.print(" "+max[i][j]+" ");
        }
         System.out.print(max[i][j]+" ");  
       }
       System.out.print("\t");
       for (int j=0;j<n;j++) {
        if(allocation[i][j]>9){
         System.out.print(" "+allocation[i][j]+" ");
        }
          System.out.print(allocation[i][j]+" ");
       }
       System.out.print("\t\t ");
       for (int j=0;j<n;j++) {
        if(need[i][j]>9){
         System.out.print(" "+need[i][j]+" ");
        }
          System.out.print(need[i][j]+" ");
       }
       System.out.print("\t");
       if (i==0) {
        for (int j=0;j<n;j++) {
         if(available[j]>9){
           System.out.print(" "+available[j]+" ");
         }
         System.out.print(available[j]+" ");
        }
       }
       System.out.println();
     }   
     System.out.println("------------------------------------------");
    }
  
    /************************** 安全性序列检查（安全性）************************/
  public boolean Security_check() {
   int[] work = new int[n];
   for (int i=0;i<n;i++) {
    work[i] = available[i];// 把available的值赋给work
   }
   finish = new boolean[m];
   for (int i = 0; i < m; i++) {// 开始把进程全部置未分配状态 都为false；
    finish[i] = false;
   }

   int num = 0;// 对每个进程都要把所有资源都进行比较
   int num1 = 0;//记录进程号
   int count = 0;// 记录可以分配的序列
   int count1 = 0;// 记录所有序列是否分配
   p = new int[m];// 找到安全序列
   
   while (num1<m) {
    for (int i=0;i<m;i++) {
     if (finish[i] == false) {// 判断finish的状态，如果为true说明刚才已经找到，不需要重复。
      for (int j=0;j<n;j++) {
       if (need[i][j] <= work[j]) {// 比较一个进程的各种资源是否满足条件
        num++;
       }
      }
      if (num == n) {// 如果一个进程所有资源都满足条件need<work,则找到了一个进程满足
       for (int k=0;k<n;k++) {
        work[k] = work[k] + allocation[i][k];
       }
       finish[i] = true;// 找到一个进程满足
       p[count++] = i;// 记录找到的是第几个进程
      }
     }
     num = 0;// 必须把它清零，重新来找下个资源种类的每种是否都满足条件
    }
    num1++;
   }

   // 记录有多少个序列；
   for (int i=0;i<m;i++) {
    if (finish[i] == true) {
     count1++;// 检测是否所有的进程最后都是true,
    }
   }
   if (count1 == m) {// 如果序列里面总数等于总共有多少程序，就找到了安全的序列。并且输出。反之没有找到
    System.out.println("存在一个安全序列，安全序列为:");
    for (int i=0;i<m;i++) {
     if (i != m-1) {
      System.out.print("P"+p[i]+"-->");
     } else {
      System.out.println("P"+p[i]);
     }
    }
    System.out.println("----------------------------------------------------");
    return true;
   } else {
    System.out.println( "没有找到一个安全序列，系统处于不安全状态！");
    return false;
   }
  }
/************************** 进程请求******************************/
  public void checkRequest() {
   int process = 0;// 记录输入的是第几个进程
   int count2 = 0;// 记录试分配过程中满足条件的个数
   boolean flag = true;// 主要防止输入的数字已经超出了本来process数量，则要求重新输入
   System.out.println("请输入要申请的第几个进程，注意进程p下标是从0开始的");
   while (flag) {
    process = input.nextInt();
    if (process > m) {
     flag = true;
     System.out.println("输入超出了本来进程的范围，请重新输入！");
    } else {
     flag = false;

    }
   }
   System.out.println("第"+process+"个进程提出请求");;
   int[] request = new int[n];
   System.out.println("输入要请求的资源Request:");
   for (int i=0;i<n;i++) {
    request[i] = input.nextInt();
   }
   // 判断是否可以分配
   for (int i=0;i<n;i++) {
    if (request[i] <= need[process][i] && request[i] <= available[i]) {
     count2++;// 判断是否每个进程的所有资源都满足试分配的要求，并记录。
    }
   }

   if (count2==n) {// 如果资源都满足要求，则可以进程请求（试分配）
    for (int j=0;j<n;j++) {
     allocation[process][j] += request[j]; //注意数组下标是从0开始的
     need[process][j] -= request[j];
     available[j] -= request[j];
    }
    System.out.println("试分配如下-------->");
    print();// 打印试分配的结果
    System.out.println("进行安全性判断");
    flag = Security_check();// 判断是否为安全序列
    
    if (flag==false) { //如果是分配后不能找到一个安全序列，则返回，不进行分配
     for (int j=0;j<n;j++) {
      allocation[process][j] -= request[j]; //注意数组下标是从0开始的
      need[process][j] += request[j];
      available[j] += request[j];
     }
    
     
    }else{//资源回收
     for (int j=0;j<n;j++) {
      
      available[j]+=allocation[process][j];
     }
     System.out.println("----------------进行资源回收后情况表------------------");
     print();
    }
   } else {
    System.out.println("不能进行试分配,也就找不到安全序列");
    
    
   }
  }
 }
试试其它关键字
　银行家算法　
同语言下
可能有用的
我是it爱好者贡献的其它代码(2)