用java写一个银行家算法

好的，银行家算法是一种避免死锁的算法，以下是Java实现：

import java.util.*;

public class BankerAlgorithm {
    private int[][] maximum; // 最大需求矩阵
    private int[][] allocation; // 已分配矩阵
    private int[][] need; // 需求矩阵
    private int[] available; // 可用资源向量
    private int[] work; // 工作向量
    private int[] safeSequence; // 安全序列

    public BankerAlgorithm(int[][] maximum, int[][] allocation, int[] available) {
        this.maximum = maximum;
        this.allocation = allocation;
        this.need = new int[maximum.length][maximum[0].length];
        this.available = available;
        this.work = new int[available.length];
        this.safeSequence = new int[maximum.length];

        // 初始化需求矩阵
        for (int i = 0; i < maximum.length; i++) {
            for (int j = 0; j < maximum[0].length; j++) {
                need[i][j] = maximum[i][j] - allocation[i][j];
            }
        }
    }

    // 判断是否满足需求矩阵
    private boolean isNeedLessOrEqualWork(int i) {
        for (int j = 0; j < need[i].length; j++) {
            if (need[i][j] > work[j]) {
                return false;
            }
        }
        return true;
    }

    // 执行银行家算法
    public boolean isSafe() {
        int count = 0; // 安全序列计数
        boolean[] finish = new boolean[maximum.length]; // 进程完成标志

        // 初始化工作向量
        for (int i = 0; i < available.length; i++) {
            work[i] = available[i];
        }

        while (count < maximum.length) {
            boolean canAllocate = false;

            for (int i = 0; i < maximum.length; i++) {
                // 如果进程未完成且需求矩阵小于等于工作向量
                if (!finish[i] && isNeedLessOrEqualWork(i)) {
                    // 分配资源
                    for (int j = 0; j < work.length; j++) {
                        work[j] += allocation[i][j];
                    }
                    // 标记进程已完成
                    finish[i] = true;
                    // 将进程添加到安全序列
                    safeSequence[count] = i;
                    count++;
                    canAllocate = true;
                }
            }

            // 如果没有进程可以分配资源，则不安全
            if (!canAllocate) {
                return false;
            }
        }

        return true;
    }

    // 打印安全序列
    public void printSafeSequence() {
        System.out.println("Safe sequence:");
        for (int i = 0; i < safeSequence.length; i++) {
            System.out.print("P" + safeSequence[i]);
            if (i != safeSequence.length - 1) {
                System.out.print(" -> ");
            }
        }
        System.out.println();
    }
}

这里是一个使用示例：

public class Main {
    public static void main(String[] args) {
        int[][] maximum = {
            {7, 5, 3},
            {3, 2, 2},
            {9, 0, 2},
            {2, 2, 2},
            {4, 3, 3}
        };
        int[][] allocation = {
            {0, 1, 0},
            {2, 0, 0},
            {3, 0, 2},
            {2, 1, 1},
            {0, 0, 2}
        };
        int[] available = {3, 3, 2};

        BankerAlgorithm bankerAlgorithm = new BankerAlgorithm(maximum, allocation, available);
        if (bankerAlgorithm.isSafe()) {
            bankerAlgorithm.printSafeSequence();
        } else {
            System.out.println("Unsafe");
        }
    }
}

输出结果为：`Safe sequence: P1 -> P3 -> P4 -> P0 -> P2`。