Java~操作系统实验银行家算法的实现(附带源码)，java面试大全带答案

最新推荐文章于 2024-05-30 12:58:04 发布
最新推荐文章于 2024-05-30 12:58:04 发布
阅读量730 收藏 24
点赞数 11
分类专栏： 2024年程序员学习 文章标签： java 面试 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62289824/article/details/136926119
版权

//如果该进程已经得到过足够资源就不进行判断

if (!p.finish) {

//如果该进程不需要等待就直接返回false

if (!needWait§) {

return false;

}

}

}

return true;

}

private void mainOperation(PCB pcb) {

//运行到这说明该进程可以得到足够的资源,那么直接将该进程已分配的资源放回到系统中

//并将finish改为true

for (int i = 0; i < this.work.length; i++) {

this.work[i].num += pcb.allocation[i].num;

pcb.finish = true;

}

}

private boolean needWait(PCB pcb) {

//挨个判断此时pcb这个进程所需要的每个资源,如果need大于系统当前可分配资源,就说明需要等待

for (int i = 0; i < this.work.length; i++) {

if (this.work[i].num < pcb.need[i].num) {

return true;

}

}

return false;

}

}

测试数据及结果

======================================================================

数据

在这里插入图片描述

import java.util.Scanner;

public class Test {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

System.out.print(“输入资源有几种:”);

int resKindNum = scan.nextInt();

Resources[] Available = new Resources[resKindNum];//系统总资源

System.out.println();

System.out.println(“输入每个系统资源名称、系统资源数量”);

for (int i = 0; i < Available.length; i++) {

System.out.println(“初始化第” + (i +1) + “个资源”);

System.out.println();

System.out.print(“资源名称:”);

String name = scan.next();

System.out.println();

System.out.print(“该资源数量:”);

int num = scan.nextInt();

Available[i] = new Resources(name, num);

System.out.println();

System.out.println(“第” + (i +1) + “个资源初始化完毕”);

System.out.println(“====================”);

}

System.out.println();

System.out.println(“系统资源初始化完毕,开始初始化进程”);

System.out.println();

System.out.print(“输入进程个数:”);

int pcbNums = scan.nextInt();

PCB[] pcbs = new PCB[pcbNums];

for (int i = 0; i < pcbNums; i++) {

System.out.println(“初始化第” + (i +1) + “个进程”);

System.out.println();

System.out.print(“输入进程名:”);

String name = scan.next();

System.out.println();

System.out.print(“输入该进程最大需求资源:”);

Resources[] max = new Resources[resKindNum];

int[] maxResNum = new int[resKindNum];

for (int j = 0; j < resKindNum; j++) {

maxResNum[j] = scan.nextInt();

}

for (int j = 0; j < max.length; j++) {

max[j] = new Resources(Available[j].name, maxResNum[j]);

}

System.out.println();

System.out.print(“输入该进程已分配资源数目:”);

Resources[] allocation = new Resources[resKindNum];

int[] allocReesNum = new int[resKindNum];

for (int j = 0; j < resKindNum; j++) {

allocReesNum[j] = scan.nextInt();

}

for (int j = 0; j < allocation.length; j++) {

allocation[j] = new Resources(Available[j].name, allocReesNum[j]);

}

System.out.println();

//此时一个进程的所有需要的东西都已输入完毕

pcbs[i] = new PCB(name, max, allocation);

System.out.println(“第” + (i +1) + “个进程初始化完毕”);

System.out.println(“====================”);

}

System.out.println();

System.out.println(“所有进程初始化完毕,开始资源分配”);

System.out.println();

boolean key = true;

while (key) {

BetterBankerAlgorithm bankerAlgorithm = new BetterBankerAlgorithm(Available, pcbs);

bankerAlgorithm.resAllocation();

System.out.println();

System.out.println("是否需要再次申请资源输入: y or n ");

char ch = scan.next().charAt(0);

if (ch == ‘n’ || ch == ‘N’) {

key = false;

} else {

System.out.print(“输入要申请资源的进程名:”);

String name = scan.next();

System.out.println();

System.out.print(“输入要申请资源的数量:”);

int[] res = new int[resKindNum];

for (int i = 0; i < resKindNum; i++) {

res[i] = scan.nextInt();

}

System.out.println();

for (PCB p : pcbs

) {

p.finish = false;

if (p.name.equals(name)) {

for (int i = 0; i < p.allocation.length; i++) {

p.allocation[i].num += res[i];

}

}

}

System.out.println();

System.out.println(“再次申请资源完毕,开始资源分配”);

System.out.println();

}

}

}

}

结果

输入资源有几种:4

输入每个系统资源名称、系统资源数量

初始化第1个资源

资源名称:R1

该资源数量:6

第1个资源初始化完毕

====================

初始化第2个资源

资源名称:R2

该资源数量:7

第2个资源初始化完毕

====================

初始化第3个资源

资源名称:R3

该资源数量:12

第3个资源初始化完毕

====================

初始化第4个资源

资源名称:R4

该资源数量:12

第4个资源初始化完毕

====================

系统资源初始化完毕,开始初始化进程

输入进程个数:5

初始化第1个进程

输入进程名:P0

输入该进程最大需求资源:0 0 1 2

输入该进程已分配资源数目:0 0 1 2

第1个进程初始化完毕

====================

初始化第2个进程

输入进程名:P1

输入该进程最大需求资源:2 7 5 0

输入该进程已分配资源数目:2 0 0 0

第2个进程初始化完毕

====================

初始化第3个进程

输入进程名:P2

输入该进程最大需求资源:6 6 5 6

输入该进程已分配资源数目:0 0 3 4

第3个进程初始化完毕

====================

初始化第4个进程

输入进程名:P3

输入该进程最大需求资源:4 3 5 6

输入该进程已分配资源数目:2 3 5 4

第4个进程初始化完毕

====================

初始化第5个进程

输入进程名:P4

输入该进程最大需求资源:0 6 5 2

输入该进程已分配资源数目:0 3 3 2

第5个进程初始化完毕

====================

所有进程初始化完毕,开始资源分配

P0进程已得到足够资源

此时系统可用资源为:

====================

资源R1有2

资源R2有1

资源R3有1

资源R4有2

====================

P3进程已得到足够资源

此时系统可用资源为:

====================

资源R1有4

资源R2有4

资源R3有6

资源R4有6

====================

P4进程已得到足够资源

此时系统可用资源为:

====================

资源R1有4

资源R2有7

资源R3有9

资源R4有8

====================

P1进程已得到足够资源

此时系统可用资源为:

====================

资源R1有6

资源R2有7

资源R3有9

资源R4有8

====================

P2进程已得到足够资源

此时系统可用资源为:

====================

资源R1有6

资源R2有7

资源R3有12

资源R4有12

====================

系统处于安全状态

是否需要再次申请资源输入: y or n

Y

输入要申请资源的进程名:P2

输入要申请资源的数量:0 1 0 0

再次申请资源完毕,开始资源分配

P0进程已得到足够资源

小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
img
img
img

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）
img

最后

做任何事情都要用心，要非常关注细节。看起来不起眼的、繁琐的工作做透了会有意想不到的价值。
当然要想成为一个技术大牛也需要一定的思想格局，思想决定未来你要往哪个方向去走, 建议多看一些人生规划方面的书籍,多学习名人的思想格局，未来你的路会走的更远。

更多的技术点思维导图我已经做了一个整理，涵盖了当下互联网最流行99%的技术点，在这里我将这份导图分享出来，以及为金九银十准备的一整套面试体系，上到集合，下到分布式微服务

L9-1711051425960)]
[外链图片转存中…(img-XsgrN4Di-1711051425961)]
[外链图片转存中…(img-bFhRkTVh-1711051425961)]

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）
[外链图片转存中…(img-3sHE0gbg-1711051425962)]

最后

做任何事情都要用心，要非常关注细节。看起来不起眼的、繁琐的工作做透了会有意想不到的价值。
当然要想成为一个技术大牛也需要一定的思想格局，思想决定未来你要往哪个方向去走, 建议多看一些人生规划方面的书籍,多学习名人的思想格局，未来你的路会走的更远。

更多的技术点思维导图我已经做了一个整理，涵盖了当下互联网最流行99%的技术点，在这里我将这份导图分享出来，以及为金九银十准备的一整套面试体系，上到集合，下到分布式微服务

[外链图片转存中…(img-RJ3Hm1CI-1711051425962)]

[外链图片转存中…(img-6u0Z4Vr4-1711051425963)]

[外链图片转存中…(img-K5IHW7g6-1711051425965)]

[外链图片转存中…(img-aEo3lTkx-1711051425966)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

还记得儿时吗
关注
  • 11
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java~操作系统实验银行家算法的实现(附带源码)
2301_79098963的博客
04-11 869
什么是ActiveMQ?ActiveMQ服务器宕机怎么办？丢消息怎么办？持久化消息非常慢怎么办？消息的不均匀消费怎么办？死信队列怎么办？ActiveMQ中的消息重发时间间隔和重发次数吗？
银行家算法java实现
08-22
经典算法 java实现 部分代码 // 系统拥有的初始资源数 public static int AVAILABLE[] = { 10, 5, 7 }; // 系统已给每个进程分配的资源数 public static int ALLOCATION[][] = { { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } }; // 每个进程还需要的资源数 public static int NEED[][] = { { 7, 5, 3 }, { 3, 2, 2 }, { 9, 0, 2 }, { 2, 2, 2 }, { 4, 3, 3 } }; // 每次申请的资源数 public static int Request[] = { 0, 0, 0 }; // 进程数与资源数 public static int M = 5, N = 3; int FALSE = 0; int TRUE = 1; public void showdata() { int i, j; System.out.print("系统可用的资源数为:/n"); for (j = 0; j < N; j++) { System.out.print("资源" + j + ":" + AVAILABLE[j] + " "); } System.out.println(); System.out.println("各进程还需要的资源量:"); for (i = 0; i < M; i++) { System.out.print("进程" + i + ":"); for (j = 0; j < N; j++) { System.out.print("资源" + j + ":" + NEED[i][j] + " "); } System.out.print("/n"); } System.out.print("各进程已经得到的资源量: /n"); for (i = 0; i < M; i++) { System.out.print("进程"); System.out.print(i); for (j = 0; j < N; j++) { System.out.print("资源" + j + ":" + ALLOCATION[i][j] + " "); } System.out.print("/n");
Java实现银行家算法（课程设计）
LF__plus的博客
09-05 1300
在第一次循环中，找到一个满足条件的进程，即进程的需求小于等于工作向量中的可用资源数量，并且进程未完成。在第二次循环中，找到一个满足条件的进程，即进程的需求小于等于工作向量中的可用资源数量，并且进程未完成。在第三次循环中，找到一个满足条件的进程，即进程的需求小于等于工作向量中的可用资源数量，并且进程未完成。在第四次循环中，找到一个满足条件的进程，即进程的需求小于等于工作向量中的可用资源数量，并且进程未完成。此时，所有进程都完成，说明系统是安全的。因此，根据银行家算法的判断，系统是安全的，可以进行资源的分配。
用Java实现银行家算法操作系统实验
m0_62840971的博客
12-27 511
本文主要是用Java来实现操作系统实验：银行家算法。银行家算法是一种用于避免死锁的资源分配算法，它通过安全性检查来决定是否为进程分配资源，以确保系统不会陷入死锁状态。这里面主要包括进程名，最大需求量，已分配资源数，仍需资源数，未分配的资源。在看这段代码之前，我建议读者先去了解银行家算法，再来阅读本文。希望本文对你有所帮助，如果你觉得有用的不妨点个小小的赞。
JAVA 面试大全
小鱼星空的博客
11-25 4224
Java相关 基础&进阶篇 1.什么是Java Java是一门面向对象的高级编程语言，不仅吸收了C++语言的各种优点，比如继承了C++语言面向对象的 技术核心。还摒弃了C++里难以理解的多继承、指针等概念，，同时也增加了垃圾回收机制，释放掉不 被使用的内存空间，解决了管理内存空间的烦恼。 因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地 实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 。 2. Java的特点有哪些 Java 语言是一种
Java面试题大全(总结)
qq_45947630的博客
03-05 1389
面试大全(Java)
Java面试题目和答案
蜕变
03-09 1525
Java面向对象有哪些特征，如何应用 ​ 面向对象编程是利用类和对象编程的一种思想。万物可归类，类是对于世界事物的高度抽象 ，不同的事物之间有不同的关系 ，一个类自身与外界的封装关系，一个父类和子类的继承关系， 一个类和多个类的多态关系。万物皆对象，对象是具体的世界事物，面向对象的三大特征封装，继承，多态。封装，封装说明一个类行为和属性与其他类的关系，低耦合，高内聚；继承是父类和子类的关系，多态说的是类与类的关系。 ​ 封装隐藏了类的内部实现机制，可以在不影响使用的情况下改变类的内部结构，同时也保护了数
2022 Java面试题
热门推荐
qq_44785726的博客
02-18 1万+
Java面向对象有哪些特征，如何应用 ​ 面向对象编程是利用类和对象编程的一种思想。万物可归类，类是对于世界事物的高度抽象 ，不同的事物之间有不同的关系 ，一个类自身与外界的封装关系，一个父类和子类的继承关系， 一个类和多个类的多态关系。万物皆对象，对象是具体的世界事物，面向对象的三大特征封装，继承，多态。封装，封装说明一个类行为和属性与其他类的关系，低耦合，高内聚；继承是父类和子类的关系，多态说的是类与类的关系。 ​ 封装隐藏了类的内部实现机制，可以在不影响使用的情况下改变类的内部结构，同时也保护了数
Java面试？看这一篇就够了
qq_33105531的博客
03-02 2588
注：以下内容仅为自己学习时所做笔记 Java面试Java面向对象有哪些特征，如何应用HashMap原理是什么，在jdk1.7和1.8中有什么区别ArrayList和LinkedList有什么区别高并发中的集合有哪些问题jdk1.8的新特性有哪些一、接口的默认方法二、Lambda 表达式三、函数式接口四、方法与构造函数引用五、Lambda 作用域六、访问局部变量七、访问对象字段与静态变量八、访问接口的默认方法九、Date API十、Annotation 注解Java中重写和重载有哪些区别接口和抽象类有哪些区别
基于java实现银行家算法的源码资料.zip
05-09
银行家算法基于java实现银行家算法的源码资料.zip银行家算法基于java实现银行家算法的源码资料.zip银行家算法基于java实现银行家算法的源码资料.zip银行家算法基于java实现银行家算法的源码资料.zip银行家算法基于...
基于java实现的银行家算法+作业调度算法源码.zip
08-18
【资源说明】 1、该资源内项目代码都是经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动...基于java实现的银行家算法+作业调度算法源码.zip
操作系统实验报告及源码(JAVA实现).zip
12-24
用C/C++编写和调试一个存储管理的模拟程序，加深对动态分区存储管理方式及实现过程的理解，了解动态分区分配方式中使用数据结构和分配算法。 实验三 存储管理模拟（二） 用C/C++编写和调试一个分页存储管理的模拟...
java实现协同过滤算法，并附带测试集
06-02
基于java实现协同过滤算法，并附带测试集，假设用户喜欢跟他过去喜欢的物品相似的物品 ，历史上相似的物品在未来也相似 ，给定用户u，找到他过去喜欢的物品的集合R(u). ， 把和R(u)相似的物品推荐给u.
Java毕业设计基于用户的协同过滤算法实现的商品推荐系统源码+数据库（高分项目）.zip
04-02
Java毕业设计基于用户的协同过滤算法实现的商品推荐系统源码+数据库（高分项目）.zip该项目是个人高分毕业设计项目源码，已获导师指导认可通过，都经过严格调试，确保可以运行！放心下载使用。 Java毕业设计基于用户...
近年来的Java面试题汇总。帮你圆大厂梦。
igg08的博客
07-28 1162
近年来的面试八股文大全。快来卷你的室友
进阶2 探索图形化编程：扩展图形组件与切片开发的魅力
最新发布
优树搭的博客
05-30 1495
当这些切片成功地通过图形程序串联起来后，在后续进行程序升级或维护时，大家会惊喜地发现，图形程序就如同清晰的路标一般，可以非常便捷地通过图形程序准确地定位到相关切片，并对这些切片进行在线查看、编辑和执行等操作。而且，这些切片的代码长度通常不会太长，相比传统开发的代码，阅读起来要容易得多，这无疑会给系统后续的工作带来极大的便利。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 1056
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
操作系统哲学家进餐问题java源码实现
05-30
好的，这里是操作系统哲学家进餐问题的Java程序实现： ```java import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class DiningPhilosophers { private static final int NUMBER_OF_PHILOSOPHERS = 5; private static final int SIMULATION_TIME = 1000; public static void main(String[] args) throws InterruptedException { Philosopher[] philosophers = new Philosopher[NUMBER_OF_PHILOSOPHERS]; Object[] forks = new Object[NUMBER_OF_PHILOSOPHERS]; Lock[] locks = new Lock[NUMBER_OF_PHILOSOPHERS]; for (int i = 0; i < NUMBER_OF_PHILOSOPHERS; i++) { forks[i] = new Object(); locks[i] = new ReentrantLock(); } for (int i = 0; i < NUMBER_OF_PHILOSOPHERS; i++) { philosophers[i] = new Philosopher(i, forks[i], forks[(i + 1) % NUMBER_OF_PHILOSOPHERS], locks[i], locks[(i + 1) % NUMBER_OF_PHILOSOPHERS]); new Thread(philosophers[i]).start(); } Thread.sleep(SIMULATION_TIME); for (Philosopher philosopher : philosophers) { philosopher.setFull(true); } } } class Philosopher implements Runnable { private final int id; private final Object leftFork; private final Object rightFork; private final Lock leftLock; private final Lock rightLock; private volatile boolean isFull = false; public Philosopher(int id, Object leftFork, Object rightFork, Lock leftLock, Lock rightLock) { this.id = id; this.leftFork = leftFork; this.rightFork = rightFork; this.leftLock = leftLock; this.rightLock = rightLock; } @Override public void run() { try { while (!isFull) { think(); pickUpForks(); eat(); putDownForks(); } } catch (InterruptedException e) { Thread.currentThread().interrupt(); return; } } private void think() throws InterruptedException { System.out.println("Philosopher " + id + " is thinking"); Thread.sleep((long) (Math.random() * 10000)); } private void pickUpForks() throws InterruptedException { leftLock.lock(); try { System.out.println("Philosopher " + id + " picked up left fork"); rightLock.lock(); try { System.out.println("Philosopher " + id + " picked up right fork"); } catch (Exception e) { leftLock.unlock(); throw e; } } catch (Exception e) { rightLock.unlock(); throw e; } } private void eat() throws InterruptedException { System.out.println("Philosopher " + id + " is eating"); Thread.sleep((long) (Math.random() * 10000)); } private void putDownForks() { leftLock.unlock(); rightLock.unlock(); System.out.println("Philosopher " + id + " put down forks"); } public void setFull(boolean isFull) { this.isFull = isFull; } } ``` 这个程序中，有5个哲学家和5个餐叉，每个哲学家需要同时拿到左右两边的餐叉才能进餐，否则需要等待。使用 `Lock` 和 `ReentrantLock` 来实现锁定餐叉。程序的运行时间为1000毫秒，每个哲学家会先思考一段时间，然后尝试拿起餐叉，进餐，然后放下餐叉，最后再开始思考。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值