java写银行家算法代码

银行家算法是一种避免死锁的重要方法，它的思路是预分配资源，然后判断新状态下是否状态安全，如果安全状态，则判断一下该对应进程是否满足执行的全部资源，如果满足，就回收掉该进程的资源，如果不满足则不作处理。如果是不安全状态，则进行状态的回退。下面是Java实现银行家算法的代码：

1. 首先定义一个进程类Process，用来标记进程的名称，进程的其他属性（need，allocation等）都在Bank的矩阵中包含。

2. 定义一个Bank类，用来实现银行家算法的主要逻辑。其中包含了银行家算法的三个主要函数：securityExamine()、request()和printState()。

3. securityExamine()函数用来检查系统是否处于安全状态。

4. request()函数用来处理进程的资源请求。

5. printState()函数用来打印当前系统的状态。

下面是Java实现银行家算法的代码：

import java.util.Scanner;

/**
 * 进程类，主要是用来标记进程的名称，进程的其他属性（need，allocation等）都在Bank的矩阵中包含
 */
class Process {
    /** 进程名称 */
    private String name;

    /**
     * 构造函数
     * @param name 进程名称
     */
    public Process(String name) {
        this.name = name;
    }

    /**
     * 获取进程名称
     * @return 返回对应进程的名称
     */
    public String getName() {
        return name;
    }

    /**
     * 设置进程名称
     * @param name 传入对应进程的名称进行设置操作
     */
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Process{" +
                "name='" + name + '\'' +
                '}';
    }
}

/**
 * 银行家算法类
 */
public class Bank {
    /** 系统中可用的资源 */
    private int[] available;
    /** 系统中所有进程所需的最大资源 */
    private int[][] max;
    /** 系统中所有进程已经分配的资源 */
    private int[][] allocation;
    /** 系统中所有进程还需要的资源 */
    private int[][] need;
    /** 系统中所有进程的数量 */
    private int processNum;
    /** 系统中所有进程的名称 */
    private Process[] processes;

    /**
     * 构造函数
     */
    public Bank() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入系统中可用的资源数量：");
        int resourceNum = scanner.nextInt();
        available = new int[resourceNum];
        System.out.println("请输入系统中所有进程的数量：");
        processNum = scanner.nextInt();
        max = new int[processNum][resourceNum];
        allocation = new int[processNum][resourceNum];
        need = new int[processNum][resourceNum];
        processes = new Process[processNum];
        for (int i = 0; i < processNum; i++) {
            System.out.println("请输入进程" + i + "的名称：");
            processes[i] = new Process(scanner.next());
            System.out.println("请输入进程" + i + "所需的资源数量：");
            for (int j = 0; j < resourceNum; j++) {
                max[i][j] = scanner.nextInt();
            }
        }
        System.out.println("请输入系统中可用的资源数量：");
        for (int i = 0; i < resourceNum; i++) {
            available[i] = scanner.nextInt();
        }
        // 计算need矩阵
        for (int i = 0; i < processNum; i++) {
            for (int j = 0; j < resourceNum; j++) {
                need[i][j] = max[i][j] - allocation[i][j];
            }
        }
    }

    /**
     * 检查系统是否处于安全状态
     * @return 如果系统处于安全状态，返回true；否则返回false
     */
    public boolean securityExamine() {
        int[] work = new int[available.length];
        System.arraycopy(available, 0, work, 0, available.length);
        boolean[] finish = new boolean[processNum];
        for (int i = 0; i < processNum; i++) {
            finish[i] = false;
        }
        int count = 0;
        while (count < processNum) {
            boolean flag = false;
            for (int i = 0; i < processNum; i++) {
                if (!finish[i]) {
                    boolean temp = true;
                    for (int j = 0; j < available.length; j++) {
                        if (need[i][j] > work[j]) {
                            temp = false;
                            break;
                        }
                    }
                    if (temp) {
                        for (int j = 0; j < available.length; j++) {
                            work[j] += allocation[i][j];
                        }
                        finish[i] = true;
                        count++;
                        flag = true;
                    }
                }
            }
            if (!flag) {
                break;
            }
        }
        if (count == processNum) {
            System.out.println("系统处于安全状态！");
            return true;
        } else {
            System.out.println("系统处于不安全状态！");
            return false;
        }
    }

    /**
     * 处理进程的资源请求
     */
    public void request() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入请求资源的进程名称：");
        String processName = scanner.next();
        int processIndex = -1;
        for (int i = 0; i < processNum; i++) {
            if (processes[i].getName().equals(processName)) {
                processIndex = i;
                break;
            }
        }
        if (processIndex == -1) {
            System.out.println("没有找到对应的进程！");
            return;
        }
        System.out.println("请输入请求的资源数量：");
        int[] request = new int[available.length];
        for (int i = 0; i < available.length; i++) {
            request[i] = scanner.nextInt();
        }
        // 判断请求是否合法
        for (int i = 0; i < available.length; i++) {
            if (request[i] > need[processIndex][i]) {
                System.out.println("请求的资源数量超过了进程所需的资源数量！");
                return;
            }
            if (request[i] > available[i]) {
                System.out.println("请求的资源数量超过了系统中可用的资源数量！");
                return;
            }
        }
        // 模拟分配资源
        for (int i = 0; i < available.length; i++) {
            available[i] -= request[i];
            allocation[processIndex][i] += request[i];
            need[processIndex][i] -= request[i];
        }
        // 检查系统是否处于安全状态
        if (securityExamine()) {
            System.out.println("资源分配成功！");
        } else {
            // 回滚分配的资源
            for (int i = 0; i < available.length; i++) {
                available[i] += request[i];
                allocation[processIndex][i] -= request[i];
                need[processIndex][i] += request[i];
            }
            System.out.println("资源分配失败！");
        }
    }

    /**
     * 打印当前系统的状态
     */
    public void printState() {
        System.out.println("系统中可用的资源数量：");
        for (int i = 0; i < available.length; i++) {
            System.out.print(available[i] + " ");
        }
        System.out.println();
        System.out.println("系统中所有进程所需的最大资源：");
        for (int i = 0; i < processNum; i++) {
            for (int j = 0; j < available.length; j++) {
                System.out.print(max[i][j] + " ");
            }
            System.out.println();
        }
        System.out.println("系统中所有进程已经分配的资源：");
        for (int i = 0; i < processNum; i++) {
            for (int j = 0; j < available.length; j++) {
                System.out.print(allocation[i][j] + " ");
            }
            System.out.println();
        }
        System.out.println("系统中所有进程还需要的资源：");
        for (int i = 0; i < processNum; i++) {
            for (int j = 0; j < available.length; j++) {
                System.out.print(need[i][j] + " ");
            }
            System.out.println();
        }
    }
}