银行家算法java实现

package com.cch.entity;  
  
import java.util.Scanner;  
  
public class Banker {  
    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 getData（） {  
        System.out.println（“请输入ABC三类资源的数目：“）;  
        // 输入ABC三类资源数量  
        for （int i = 0; i < 3; i++） {  
            available[i] = scanner.nextInt（）;  
        }  
        // 输入进程对三类资源的最大需求  
        for （int i = 0; i < 5; i++） {  
            System.out.println（“请输入进程“ + i + “对ABC三类资源的最大需求“）;  
            for （int j = 0; j < 3; j++） {  
                max[i][j] = scanner.nextInt（）;  
            }  
        }  
        // 输入进程分配的三类资源数  
        for （int i = 0; i < 5; i++） {  
            System.out.println（“请输入进程“ + i + “已分配的ABC三类资源数“）;  
            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（）;  
                }  
            }  
            changeData（thread）;  
            if （check（thread）） {  
                getThread（）;  
            } else {  
                recoverData（thread）;  
                getThread（）;  
            }  
  
        }  
    }  
  
    // thread线程请求响应后，试探性分配资源  
    public