使用Java语言，用银行家算法设计并实现一个小型的死锁避免系统，有GUI页面； 系统中体现银行家算法及安全性算法，用户请求及系统当前的资源分配状态从键盘输入； 输出判断当前的系统状态是否安全，若安全，给出至少一个安全序列；若不安全，给出原因提示；

好的，我可以给你提供一个银行家算法的Java实现，你可以在此基础上添加GUI页面。以下是代码：

import java.util.Scanner;

public class BankerAlgorithm {
    private int[][] allocation; // 当前已分配资源矩阵
    private int[][] max; // 最大资源需求矩阵
    private int[][] need; // 剩余资源需求矩阵
    private int[] available; // 系统中可用资源向量
    private int[] work; // 系统工作向量
    private boolean[] finish; // 进程是否执行完毕标志
    private int numOfProcess; // 进程数量
    private int numOfResource; // 资源数量

    public BankerAlgorithm(int[][] allocation, int[][] max, int[] available) {
        this.allocation = allocation;
        this.max = max;
        this.available = available;
        this.numOfProcess = allocation.length;
        this.numOfResource = available.length;
        this.need = new int[numOfProcess][numOfResource];
        this.work = new int[numOfResource];
        this.finish = new boolean[numOfProcess];

        // 初始化 need 矩阵和 finish 向量
        for (int i = 0; i < numOfProcess; i++) {
            for (int j = 0; j < numOfResource; j++) {
                need[i][j] = max[i][j] - allocation[i][j];
            }
            finish[i] = false;
        }
    }

    // 判断系统是否处于安全状态
    public boolean isSafe() {
        // 初始化 work 向量
        for (int i = 0; i < numOfResource; i++) {
            work[i] = available[i];
        }

        // 执行安全性算法
        int count = 0;
        int[] safeSequence = new int[numOfProcess];
        while (count < numOfProcess) {
            boolean found = false;
            for (int i = 0; i < numOfProcess; i++) {
                if (!finish[i] && isLessOrEqual(need[i], work)) {
                    for (int j = 0; j < numOfResource; j++) {
                        work[j] += allocation[i][j];
                    }
                    finish[i] = true;
                    safeSequence[count] = i;
                    count++;
                    found = true;
                }
            }
            if (!found) {
                return false; // 没有找到符合条件的进程，系统不安全
            }
        }
        printSafeSequence(safeSequence);
        return true; // 安全状态
    }

    // 判断向量 A 是否小于等于向量 B 的每个元素
    private boolean isLessOrEqual(int[] A, int[] B) {
        for (int i = 0; i < A.length; i++) {
            if (A[i] > B[i]) {
                return false;
            }
        }
        return true;
    }

    // 执行进程申请资源
    public void requestResource(int processId, int[] request) {
        if (isLessOrEqual(request, need[processId])) {
            if (isLessOrEqual(request, available)) {
                // 暂时分配资源
                for (int i = 0; i < numOfResource; i++) {
                    available[i] -= request[i];
                    allocation[processId][i] += request[i];
                    need[processId][i] -= request[i];
                }
                // 判断系统是否处于安全状态
                if (isSafe()) {
                    System.out.println("分配成功，系统处于安全状态！");
                } else {
                    System.out.println("分配失败，系统不处于安全状态！分配已回滚。");
                    // 回滚分配
                    for (int i = 0; i < numOfResource; i++) {
                        available[i] += request[i];
                        allocation[processId][i] -= request[i];
                        need[processId][i] += request[i];
                    }
                }
            } else {
                System.out.println("无足够资源可分配，进程需等待！");
            }
        } else {
            System.out.println("申请资源超过进程需求量，分配失败！");
        }
    }

    // 输出安全序列
    private void printSafeSequence(int[] safeSequence) {
        System.out.print("安全序列为：");
        for (int i = 0; i < safeSequence.length; i++) {
            System.out.print("P" + safeSequence[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        // 从键盘输入数据
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入进程数量：");
        int numOfProcess = scanner.nextInt();
        System.out.print("请输入资源数量：");
        int numOfResource = scanner.nextInt();

        int[][] allocation = new int[numOfProcess][numOfResource];
        int[][] max = new int[numOfProcess][numOfResource];
        int[] available = new int[numOfResource];

        System.out.println("请输入已分配资源矩阵：");
        for (int i = 0; i < numOfProcess; i++) {
            for (int j = 0; j < numOfResource; j++) {
                allocation[i][j] = scanner.nextInt();
            }
        }

        System.out.println("请输入最大资源需求矩阵：");
        for (int i = 0; i < numOfProcess; i++) {
            for (int j = 0; j < numOfResource; j++) {
                max[i][j] = scanner.nextInt();
            }
        }

        System.out.println("请输入每个资源的总数：");
        for (int i = 0; i < numOfResource; i++) {
            available[i] = scanner.nextInt();
        }

        BankerAlgorithm banker = new BankerAlgorithm(allocation, max, available);

        // 处理用户请求
        while (true) {
            System.out.println("请输入进程编号和其请求的资源数量（以空格分隔，输入 -1 结束）：");
            int processId = scanner.nextInt();
            if (processId == -1) {
                break;
            }
            int[] request = new int[numOfResource];
            for (int i = 0; i < numOfResource; i++) {
                request[i] = scanner.nextInt();
            }
            banker.requestResource(processId, request);
        }
    }
}

在此代码中，我们首先从键盘输入进程数量、资源数量、已分配资源矩阵、最大资源需求矩阵和每个资源的总数。然后，我们创建一个 BankerAlgorithm 对象，并利用它的 requestResource() 方法来处理用户请求。在该方法中，我们判断请求是否能够满足，如果能够满足，那么我们暂时分配资源，并判断系统是否处于安全状态。如果系统处于安全状态，那么分配成功，否则分配失败，我们需要回滚分配。

最后，在 isSafe() 方法中，我们使用安全性算法来判断系统是否处于安全状态。如果系统处于安全状态，那么我们输出至少一个安全序列，否则我们返回 false。

以上是一个简单的银行家算法Java实现，你可以在此基础上添加GUI页面来实现你需要的功能。