Java~操作系统实验银行家算法的实现(附带源码)

• 一、实验内容

• 二、实验目的

• 三、实验原理

• • 3.1、银行家算法中的数据结构

• 3.2、银行家算法

• 3.3、安全性算法

• 四、实现代码

• 测试数据及结果

• • 数据

• 结果

一、实验内容

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

银行家算法的实现。

二、实验目的

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

银行家算法是一种最有代表性的避免死锁的算法。在避免死锁方法中允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。通过编写一个模拟动态资源分配的银行家算法程序，帮助学生进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念，并掌握避免死锁的具体实施方法。

三、实验原理

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

3.1、银行家算法中的数据结构

---

1）可利用资源向量Available

是个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目。如果Available［j］=K，则表示系统中现有Rj类资源K个。

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

2）最大需求矩阵Max

这是一个n×m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。如果Max［i,j］=K，则表示进程i需要Rj类资源的最大数目为K。

3）分配矩阵Allocation

这也是一个n×m的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。如果Allocation［i,j］=K，则表示进程i当前已分得Rj类资源的数目为K。

4）需求矩阵Need。

这也是一个n×m的矩阵，用以表示每一个进程尚需的各类资源数。如果Need［i,j］=K，则表示进程i还需要Rj类资源K个，方能完成其任务。

Need［i,j］=Max［i,j］-Allocation［i,j］

//进程的数据结构

class PCB {

public String name;

public Resources[] max;//最大需求资源Max

public Resources[] allocation;//已分配资源Allocation

public Resources[] need;//需求资源Need

public boolean finish = false;//表示进程是否获得足够资源

public PCB(String name, Resources[] max, Resources[] allocation) {

this.name = name;

this.max = max;

this.allocation = allocation;

this.need = new Resources[max.length];

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

this.need[i] = new Resources(max[i].name, max[i].num - allocation[i].num);

}

}

@Override

public String toString() {

return this.name +(this.finish ? “进程已得到足够资源” : “需要等待”);

}

}

3.2、银行家算法

---

设Requesti是进程Pi的请求向量，如果Requesti［j］=K，表示进程Pi需要K个Rj类型的资源。当Pi发出资源请求后，系统按下述步骤进行检查：

(1)如果Requesti［j］≤Need［i,j］，便转向步骤(2)；否则认为出错，因为它所需要的资源数已超过它所宣布最大值。

(2)如果Requesti［j］≤Available［j］，便转向步骤(3)；否则，表示尚无足够资源，Pi须等待。

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;

}

(3)系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：

Available［j］=Available［j］-Requesti［j］;

Allocation［i,j］=Allocation［i,j］+Requesti［j］;

Need［i,j］=Need［i,j］-Requesti［j］;

系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。若安全，才正式将资源分配给进程Pi，以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。

//进行资源分配

public void resAllocation() {

//对进程进行循环资源分配,当所有进程都需要等待或者所有进程都为安全状态退出循环

for (int i = 0; !ifSafe() && !ifAllNeedWait(); i++) {

//实现循环

if (i == this.pcbs.length) {

i = 0;

}

//判断当前这个进程是否已经获得过足够资源

if (pcbs[i].finish) {

continue;

}

//判断当前这个进程是否需要等待

if (! needWait(pcbs[i])) {

//进行资源分配

mainOperation(pcbs[i]);

System.out.println(pcbs[i]);

System.out.println();

displayWorks();

}

}

System.out.println();

if (ifSafe()) {

System.out.println(“系统处于安全状态”);

} else {

System.out.println(“系统处于不安全状态”);

}

}

3.3、安全性算法

---

1）设置两个向量：

工作向量Work: 它表示系统可提供给进程继续运行所需的各类资源数目，它含有m个元素，在执行安全算法开始时，Work=Available;

工作向量Finish: 它表示系统是否有足够的资源分配给进程，使之运行完成。开始时先做Finish［i］=false; 当有足够资源分配给进程时， 再令Finish［i］=true。

2）从进程集合中找到一个能满足下述条件的进程： 

Finish［i］=false;

Need［i,j］≤Work［j］；若找到，执行 (3)，否则，执行 (4)

3）当进程Pi获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：

Work［j］=Work［i］+Allocation［i,j］;

Finish［i］=true;

go to step 2;

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;

}

}

4）如果所有进程的Finish［i］=true都满足， 则表示系统处于安全状态；否则，系统处于不安全状态

四、实现代码

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

/**

• 优化银行家算法,实现资源再次申请

*/

//系统资源的数据结构

class Resources {

public String name;

public int num;

public Resources(String name, int num) {

this.name = name;

this.num = num;

}

@Override

public String toString() {

return “资源”+ name + “有” + num;

}

}

//进程的数据结构

class PCB {

public String name;

public Resources[] max;//最大需求资源Max

public Resources[] allocation;//已分配资源Allocation

public Resources[] need;//需求资源Need

public boolean finish = false;//表示进程是否获得足够资源

public PCB(String name, Resources[] max, Resources[] allocation) {

this.name = name;

this.max = max;

this.allocation = allocation;

this.need = new Resources[max.length];

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

this.need[i] = new Resources(max[i].name, max[i].num - allocation[i].num);

}

}

@Override

public String toString() {

return this.name +(this.finish ? “进程已得到足够资源” : “需要等待”);

}

}

public class BetterBankerAlgorithm {

private Resources[] work;//当前可以资源

private PCB[] pcbs;//所有进程

public BetterBankerAlgorithm(Resources[] Available, PCB[] pcbs) {

this.work = Available;//一开始可用资源与系统总资源是相同的

this.pcbs = pcbs;

//计算剩余可用资源

actualWork();

}

private void actualWork() {

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

//初始系统总资源减去已分配的资源就是当前可以利用的资源

this.work[i].num = this.work[i].num - pcbsAllRes(i);

}

}

//计算所有进程已分配的第i个资源总数

private int pcbsAllRes(int index) {

int sum = 0;

for ( PCB p : pcbs

) {

sum += p.allocation[index].num;

}

return sum;

}

//判断是否为安全状态

private boolean ifSafe() {

for (PCB p : pcbs

) {

if (! p.finish) {

return false;

}

}

return true;

}

//进行资源分配

public void resAllocation() {

//对进程进行循环资源分配,当所有进程都需要等待或者所有进程都为安全状态退出循环

for (int i = 0; !ifSafe() && !ifAllNeedWait(); i++) {

//实现循环

if (i == this.pcbs.length) {

i = 0;

}

//判断当前这个进程是否已经获得过足够资源

if (pcbs[i].finish) {

continue;

}

//判断当前这个进程是否需要等待

if (! needWait(pcbs[i])) {

//进行资源分配

mainOperation(pcbs[i]);

System.out.println(pcbs[i]);

System.out.println();

displayWorks();

}

}

System.out.println();

if (ifSafe()) {

System.out.println(“系统处于安全状态”);

} else {

System.out.println(“系统处于不安全状态”);

}

}

private void displayWorks() {

System.out.println(“此时系统可用资源为:”);

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

for (Resources r : this.work

) {

System.out.println®;

}

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

}

private boolean ifAllNeedWait() {

for (PCB p : this.pcbs

) {

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

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;

}

}

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

深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

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

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

如果你觉得这些内容对你有帮助，可以扫码领取！

总结

上述知识点，囊括了目前互联网企业的主流应用技术以及能让你成为“香饽饽”的高级架构知识，每个笔记里面几乎都带有实战内容。

很多人担心学了容易忘，这里教你一个方法，那就是重复学习。

打个比方，假如你正在学习 spring 注解，突然发现了一个注解@Aspect，不知道干什么用的，你可能会去查看源码或者通过博客学习，花了半小时终于弄懂了，下次又看到@Aspect 了，你有点郁闷了，上次好像在哪哪哪学习，你快速打开网页花了五分钟又学会了。

从半小时和五分钟的对比中可以发现多学一次就离真正掌握知识又近了一步。

人的本性就是容易遗忘，只有不断加深印象、重复学习才能真正掌握，所以很多书我都是推荐大家多看几遍。哪有那么多天才，他只是比你多看了几遍书。

8943)]

[外链图片转存中…(img-LYky8IXv-1711377148943)]

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

如果你觉得这些内容对你有帮助，可以扫码领取！

总结

上述知识点，囊括了目前互联网企业的主流应用技术以及能让你成为“香饽饽”的高级架构知识，每个笔记里面几乎都带有实战内容。

很多人担心学了容易忘，这里教你一个方法，那就是重复学习。

打个比方，假如你正在学习 spring 注解，突然发现了一个注解@Aspect，不知道干什么用的，你可能会去查看源码或者通过博客学习，花了半小时终于弄懂了，下次又看到@Aspect 了，你有点郁闷了，上次好像在哪哪哪学习，你快速打开网页花了五分钟又学会了。

从半小时和五分钟的对比中可以发现多学一次就离真正掌握知识又近了一步。

[外链图片转存中…(img-m2vwOwTr-1711377148944)]

人的本性就是容易遗忘，只有不断加深印象、重复学习才能真正掌握，所以很多书我都是推荐大家多看几遍。哪有那么多天才，他只是比你多看了几遍书。

需要更多Java资料的小伙伴可以帮忙点赞+关注，点击传送门，即可免费领取！