写一个Java银行家算法

银行家算法是一种避免死锁的算法，它可以判断一个系统的资源分配是否会导致死锁的发生。以下是一个简单的Java实现：

import java.util.Scanner;

public class BankerAlgorithm {
    // 声明变量
    private int[][] max;     // 最大需求矩阵
    private int[][] allocation;  // 已分配矩阵
    private int[][] need;    // 需求矩阵
    private int[] available; // 可用资源向量
    private int processNum;  // 进程数
    private int resourceNum; // 资源种类数

    // 构造函数
    public BankerAlgorithm(int[][] max, int[][] allocation, int[] available) {
        this.max = max;
        this.allocation = allocation;
        this.available = available;
        this.processNum = allocation.length;
        this.resourceNum = available.length;
        this.need = new int[processNum][resourceNum];
        // 计算需求矩阵
        for (int i = 0; i < processNum; i++) {
            for (int j = 0; j < resourceNum; j++) {
                this.need[i][j] = max[i][j] - allocation[i][j];
            }
        }
    }

    // 安全性检查
    public boolean safetyCheck() {
        int[] work = new int[resourceNum];   // 工作向量
        boolean[] finish = new boolean[processNum];  // 是否完成
        // 初始化工作向量和是否完成
        for (int i = 0; i < resourceNum; i++) {
            work[i] = available[i];
        }
        for (int i = 0; i < processNum; i++) {
            finish[i] = false;
        }
        // 开始安全性检查
        int count = 0;
        while (count < processNum) {
            boolean found = false;
            for (int i = 0; i < processNum; i++) {
                if (!finish[i]) {
                    int j;
                    for (j = 0; j < resourceNum; j++) {
                        if (need[i][j] > work[j]) {
                            break;
                        }
                    }
                    if (j == resourceNum) {
                        for (j = 0; j < resourceNum; j++) {
                            work[j] += allocation[i][j];
                        }
                        finish[i] = true;
                        found = true;
                        count++;
                    }
                }
            }
            if (!found) {
                return false;
            }
        }
        return true;
    }

    // 请求资源
    public boolean requestResource(int processId, int[] request) {
        // 判断请求是否合法
        for (int i = 0; i < resourceNum; i++) {
            if (request[i] > need[processId][i]) {
                return false;
            }
            if (request[i] > available[i]) {
                return false;
            }
        }
        // 尝试分配资源并进行安全性检查
        for (int i = 0; i < resourceNum; i++) {
            available[i] -= request[i];
            allocation[processId][i] += request[i];
            need[processId][i] -= request[i];
        }
        if (safetyCheck()) {
            return true;
        } else {
            // 回滚操作
            for (int i = 0; i < resourceNum; i++) {
                available[i] += request[i];
                allocation[processId][i] -= request[i];
                need[processId][i] += request[i];
            }
            return false;
        }
    }

    // 打印资源分配矩阵和需求矩阵
    public void printAllocationAndNeed() {
        System.out.println("Allocation Matrix:");
        for (int i = 0; i < processNum; i++) {
            for (int j = 0; j < resourceNum; j++) {
                System.out.print(allocation[i][j] + " ");
            }
            System.out.println();
        }
        System.out.println("Need Matrix:");
        for (int i = 0; i < processNum; i++) {
            for (int j = 0; j < resourceNum; j++) {
                System.out.print(need[i][j] + " ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 输入进程数和资源种类数
        System.out.print("Enter the number of processes: ");
        int processNum = scanner.nextInt();
        System.out.print("Enter the number of resources: ");
        int resourceNum = scanner.nextInt();
        // 输入最大需求矩阵
        int[][] max = new int[processNum][resourceNum];
        System.out.println("Enter the maximum demand matrix:");
        for (int i = 0; i < processNum; i++) {
            for (int j = 0; j < resourceNum; j++) {
                max[i][j] = scanner.nextInt();
            }
        }
        // 输入已分配矩阵
        int[][] allocation = new int[processNum][resourceNum];
        System.out.println("Enter the allocation matrix:");
        for (int i = 0; i < processNum; i++) {
            for (int j = 0; j < resourceNum; j++) {
                allocation[i][j] = scanner.nextInt();
            }
        }
        // 输入可用资源向量
        int[] available = new int[resourceNum];
        System.out.println("Enter the available vector:");
        for (int i = 0; i < resourceNum; i++) {
            available[i] = scanner.nextInt();
        }
        // 创建银行家算法对象并进行安全性检查
        BankerAlgorithm bankerAlgorithm = new BankerAlgorithm(max, allocation, available);
        if (bankerAlgorithm.safetyCheck()) {
            System.out.println("The system is in safe state.");
        } else {
            System.out.println("The system is in unsafe state.");
        }
        // 请求资源并输出结果
        System.out.print("Enter the process ID for resource request: ");
        int processId = scanner.nextInt();
        System.out.print("Enter the resource request vector: ");
        int[] request = new int[resourceNum];
        for (int i = 0; i < resourceNum; i++) {
            request[i] = scanner.nextInt();
        }
        if (bankerAlgorithm.requestResource(processId, request)) {
            System.out.println("The request can be granted.");
            bankerAlgorithm.printAllocationAndNeed();
        } else {
            System.out.println("The request cannot be granted.");
        }
    }
}

这个程序中，首先读入进程数、资源种类数、最大需求矩阵、已分配矩阵和可用资源向量。然后创建一个银行家算法对象并进行安全性检查。如果系统处于安全状态，则可以进行资源请求。程序将读入请求的进程ID和资源请求向量，并进行判断，如果请求合法，则尝试分配资源并进行安全性检查。如果系统处于安全状态，则请求可以被满足，并输出资源分配矩阵和需求矩阵。否则，请求不能被满足，输出错误信息。