Java实现银行家算法

简介: Java实现银行家算法

在这里用Java做一下简单代码的实现:

/**
 * Java实现银行家算法
 *
 * @author 17122
 */
public class Test01 {
    /**
     * 数据结构
     */
    public int[][] allocation;
    public int[][] need;
    public int[] available;
    /**
     * 初始化方法
     */
    public void init() {
        allocation = new int[][]{
                {0, 0, 3, 2},
                {1, 0, 0, 0},
                {1, 3, 5, 4},
                {0, 3, 3, 2},
                {0, 0, 1, 4}
        };
        need = new int[][]{
                {0, 0, 1, 2},
                {1, 7, 5, 0},
                {2, 3, 5, 6},
                {0, 6, 5, 2},
                {0, 6, 5, 6}
        };
        available = new int[]{1, 6, 2, 2};
        System.out.println("Allocation矩阵:   Need矩阵:        Available:");
        for (int i = 0; i < allocation.length; i++) {
            for (int j = 0; j < allocation[i].length; j++) {
                System.out.print(allocation[i][j] + "  ");
            }
            System.out.print("      ");
            for (int j = 0; j < need[i].length; j++) {
                System.out.print(need[i][j] + "  ");
            }
            if (i == 0) {
                System.out.print("     ");
                for (int j = 0; j < available.length; j++) {
                    System.out.print(available[j] + "  ");
                }
            }
            System.out.println();
        }
    }
    /**
     * 请求资源方法
     *
     * @param index 请求的进程
     * @param req   请求数量
     */
    public void request(int index, int[] req) {
        //先进性数据初始化
        init();
        if (req[0] <= available[0] && req[1] <= available[1] && req[2] <= available[2] && req[3] <= available[3]) {
            //分配
            int[] process_has = allocation[index];
            int[] process_need = need[index];
            if (process_need[0] >= req[0] && process_need[1] >= req[1] && process_need[2] >= req[2] && process_need[3] >= req[3]) {
                for (int i = 0; i < process_has.length; i++) {
                    process_has[i] += req[i];
                    process_need[i] -= req[i];
                }
                for (int i = 0; i < available.length; i++) {
                    available[i] -= req[i];
                }
            }
            //检查
            if (safe()) {
                System.out.println("分配成功!");
            } else {
                System.out.println("分配后不安全,取消分配!");
            }
        } else {
            System.out.println("可用资源不足,无法分配!");
        }
    }
    /**
     * 检查方法
     *
     * @return
     */
    public boolean safe() {
        Boolean[] finish = {false, false, false, false, false};
        // 完成进程数
        int count = 0;
        // 循环圈数
        int circle = 0;
        // 安全序列
        int[] S = new int[5];
        // 设置工作向量
        int work[] = available;
        boolean flag = true;
        boolean isNeed = true;
        while (count < 5) {
            if (flag) {
                System.out.println("Process  " + "   Work  " + "       Allocation " + "        Need  " + "       Available ");
                flag = false;
            }
            for (int i = 0; i < 5; i++) {
                isNeed = true;
                for (int j = 0; j < 4; j++) {
                    if (!(finish[i] == false && need[i][j] <= work[j])) {
                        isNeed = false;
                    }
                }
                // 判断条件
                if (isNeed) {
                    System.out.print("P" + i + "      ");
                    for (int k = 0; k < 4; k++) {
                        System.out.print(work[k] + "  ");
                    }
                    System.out.print("    ");
                    for (int j = 0; j < 4; j++) {
                        work[j] += allocation[i][j];
                    }
                    // 当前进程能满足时
                    finish[i] = true;
                    // 当前序列
                    S[count] = i;
                    // 满足进程数+1
                    count++;
                    for (int j = 0; j < 4; j++) {
                        System.out.print(allocation[i][j] + "  ");
                    }
                    System.out.print("    ");
                    for (int j = 0; j < 4; j++) {
                        System.out.print(need[i][j] + "  ");
                    }
                    System.out.print("    ");
                    for (int j = 0; j < 4; j++) {
                        System.out.print(work[j] + "  ");
                    }
                    System.out.println();
                }
            }
            // 循环圈数加1
            circle++;
            // 判断是否满足所有进程需要
            if (count == 5) {
                System.out.print("安全序列为:");
                // 输出安全序列
                for (int i = 0; i < 5; i++) {
                    System.out.print("P" + S[i] + " ");
                }
                return true;
            }
            // 判断完成进程数是否小于循环圈数
            if (count < circle) {
                return false;
            }
        }
        return false;
    }
    public static void main(String[] args) {
        Test01 test01 = new Test01();
        test01.request(0, new int[]{0, 0, 1, 2});
    }
}

运行结果:


相关文章
|
2月前
|
负载均衡 NoSQL 算法
一天五道Java面试题----第十天(简述Redis事务实现--------->负载均衡算法、类型)
这篇文章是关于Java面试中Redis相关问题的笔记,包括Redis事务实现、集群方案、主从复制原理、CAP和BASE理论以及负载均衡算法和类型。
一天五道Java面试题----第十天(简述Redis事务实现--------->负载均衡算法、类型)
|
2月前
|
搜索推荐 算法 Java
手写快排:教你用Java写出高效排序算法!
快速排序(QuickSort)是经典的排序算法之一,基于分治思想,平均时间复杂度为O(n log n),广泛应用于各种场合。在这篇文章中,我们将手写一个Java版本的快速排序,从基础实现到优化策略,并逐步解析代码背后的逻辑。
81 1
|
2月前
|
设计模式 缓存 算法
揭秘策略模式:如何用Java设计模式轻松切换算法?
【8月更文挑战第30天】设计模式是解决软件开发中特定问题的可重用方案。其中,策略模式是一种常用的行为型模式,允许在运行时选择算法行为。它通过定义一系列可互换的算法来封装具体的实现,使算法的变化与客户端分离。例如,在电商系统中,可以通过定义 `DiscountStrategy` 接口和多种折扣策略类(如 `FidelityDiscount`、`BulkDiscount` 和 `NoDiscount`),在运行时动态切换不同的折扣逻辑。这样,`ShoppingCart` 类无需关心具体折扣计算细节,只需设置不同的策略即可实现灵活的价格计算,符合开闭原则并提高代码的可维护性和扩展性。
41 2
|
2月前
|
安全 算法 Java
java系列之~~网络通信安全 非对称加密算法的介绍说明
这篇文章介绍了非对称加密算法,包括其定义、加密解密过程、数字签名功能,以及与对称加密算法的比较,并解释了非对称加密在网络安全中的应用,特别是在公钥基础设施和信任网络中的重要性。
|
2月前
|
算法 Java
LeetCode经典算法题:矩阵中省份数量经典题目+三角形最大周长java多种解法详解
LeetCode经典算法题:矩阵中省份数量经典题目+三角形最大周长java多种解法详解
39 6
|
2月前
|
存储 算法 Java
LeetCode经典算法题:打家劫舍java详解
LeetCode经典算法题:打家劫舍java详解
55 2
|
2月前
|
人工智能 算法 Java
LeetCode经典算法题:井字游戏+优势洗牌+Dota2参议院java解法
LeetCode经典算法题:井字游戏+优势洗牌+Dota2参议院java解法
42 1
|
2月前
|
存储 算法 Java
LeetCode经典算法题:预测赢家+香槟塔java解法
LeetCode经典算法题:预测赢家+香槟塔java解法
40 1
|
2月前
|
数据采集 搜索推荐 算法
【高手进阶】Java排序算法:从零到精通——揭秘冒泡、快速、归并排序的原理与实战应用,让你的代码效率飙升!
【8月更文挑战第21天】Java排序算法是编程基础的重要部分,在算法设计与分析及实际开发中不可或缺。本文介绍内部排序算法,包括简单的冒泡排序及其逐步优化至高效的快速排序和稳定的归并排序,并提供了每种算法的Java实现示例。此外,还探讨了排序算法在电子商务、搜索引擎和数据分析等领域的广泛应用,帮助读者更好地理解和应用这些算法。
25 0
|
2月前
|
存储 算法 Java
LeetCode经典算法题:二叉树遍历(递归遍历+迭代遍历+层序遍历)以及线索二叉树java详解
LeetCode经典算法题:二叉树遍历(递归遍历+迭代遍历+层序遍历)以及线索二叉树java详解
65 0
下一篇
无影云桌面