• 操作系统 银行家算法（java）
千次阅读 多人点赞
2021-05-30 11:43:18

# 操作系统 银行家算法（java）

### Bank.java

import java.util.Scanner;

public class Banker {

int[] Available = new int [3]; //限制该数组范围为大小为3
int[][] Max;
int[][] Alloction;
int[][] Need;
int[][] Request;
int[] Work;

int flag;

int num = 0;//进程编号
Scanner in = new Scanner(System.in);

public Banker() {
// Max={{6,3,2},{5,6,1},{2,3,2}};

}
public void count(int num){
flag=num;
Max = new int[flag][3];
Alloction = new int[flag][3];
Need = new int[flag][3];
Request = new int[flag][3];
Work = new int[3];
}

public void setSystemVariable(){//设置各初始系统变量，并判断是否处于安全状态。
setMax();
setAlloction();
printSystemVariable();
SecurityAlgorithm();
}

public void setMax() {//设置Max矩阵
System.out.println("请设置各进程的最大需求矩阵Max：");
for (int i = 0; i < flag; i++) {
System.out.println("请输入进程P" + i + "的最大资源需求量：");
for (int j = 0; j < 3; j++) {
Max[i][j] = in.nextInt();
}
}
}

public void setAlloction() {//设置已分配矩阵Alloction
System.out.println("请设置请各进程分配矩阵Alloction：");
for (int i = 0; i < flag; i++) {
System.out.println("请输入进程P" + i + "的分配资源量：");
for (int j = 0; j < 3; j++) {
Alloction[i][j] = in.nextInt();
}
}
System.out.println("Available=Available-Alloction.");
System.out.println("Need=Max-Alloction.");
for (int i = 0; i < 3; i++) {//设置Alloction矩阵
System.out.println("请输入request：");
//for (int j = 0; j < 3; j++) {
Available[i] = in.nextInt();
//}
}
for (int i = 0; i < flag; i++) {//设置Need矩阵
for (int j = 0; j < 3; j++) {
Need[i][j] = Max[i][j] - Alloction[i][j];
}
}
}

public void printSystemVariable(){
System.out.println("此时资源分配量如下：");
System.out.println("进程  "+"   Max   "+"   Alloction "+"    Need  "+"     Available ");
for(int i=0;i<flag;i++){
System.out.print("P"+i+"  ");
for(int j=0;j<3;j++){
System.out.print(Max[i][j]+"  ");
}
System.out.print("|  ");
for(int j=0;j<3;j++){
System.out.print(Alloction[i][j]+"  ");
}
System.out.print("|  ");
for(int j=0;j<3;j++){
System.out.print(Need[i][j]+"  ");
}
System.out.print("|  ");
if(i==0){
for(int j=0;j<3;j++){
System.out.print(Available[j]+"  ");
}
}
System.out.println();
}
}

public void setRequest() {//设置请求资源量Request

System.out.println("请输入请求资源的进程编号：");
num= in.nextInt();//设置全局变量进程编号num
System.out.println("请输入请求各资源的数量：");
for (int j = 0; j < 3; j++) {
Request[num][j] = in.nextInt();
}
System.out.println("即进程P" + num + "对各资源请求Request：(" + Request[num][0] + "," + Request[num][1] + "," + Request[num][2] + ").");

BankerAlgorithm();
}

public void BankerAlgorithm() {//银行家算法
boolean T=true;
int num1=0;
boolean []panduanNeed = new boolean [flag];
boolean []panduanAvailable = new boolean [flag];
for (int k = 0; k < 3; k++) {
if(Request[num][k] <= Need[num][k]) panduanNeed[k]=true;
else panduanNeed[k] = false;
if (Request[num][k] <= Available[k]) panduanAvailable[k]=true;
else panduanAvailable[k] = false;
}
for (int q = 0; q < 3; q++) {
//if (Request[num][0] <= Need[num][0] && Request[num][1] <= Need[num][1] && Request[num][2] <= Need[num][2]) {//判断Request是否小于Need
//if (Request[num][0] <= Available[0] && Request[num][1] <= Available[1] && Request[num][2] <= Available[2]) {//判断Request是否小于Alloction
if(panduanNeed[q]==true){
if (panduanAvailable[q]==true) {
for (int i = 0; i < 3; i++) {
Available[i] -= Request[num][i];
Alloction[num][i] += Request[num][i];
Need[num][i] -= Request[num][i];
}

} else {
System.out.println("当前没有足够的资源可分配，进程P" + num + "需等待。");
T=false;
}
}else {
System.out.println("进程P" + num + "请求已经超出最大需求量Need.");
T=false;
}
}

if(T==true){
printSystemVariable();
System.out.println("现在进入安全算法：");
SecurityAlgorithm();
}
}

public void SecurityAlgorithm() {//安全算法
boolean []panduanNeedWork = new boolean [flag];
boolean[] Finish = new boolean [flag];//初始化Finish
for (int i = 0; i < flag; i++) {
Finish[i] =false;
}
int count = 0;//完成进程数
int circle=0;//循环圈数
int[] S=new int[flag];//安全序列
for (int i = 0; i < 3; i++) {//设置工作向量
Work[i] = Available[i];
}
boolean flag1 = true;
while (count < flag) {
if(flag1){
System.out.println("进程  "+"   Work  "+"   Alloction "+"    Need  "+"     Work+Alloction ");
flag1 = false;
}
for (int i = 0; i < flag; i++) {

//            	for (int q = 0; q < 3; q++) {
//					if(Need[i][q]<=Work[q]) panduanNeedWork[q]=true;
//		        	else panduanNeedWork[q] = false;
//					}
//            	int flagNeedWork=0;
//            	for (int j = 0; j < 3; j++) {
//					if (panduanNeedWork[j]==false) flagNeedWork=0;
//					else flagNeedWork=1;
//				}
//  if (Finish[i]==false&&flagNeedWork==1) {//判断条件
if (Finish[i]==false&&Need[i][0]<=Work[0]&&Need[i][1]<=Work[1]&&Need[i][2]<=Work[2]){
System.out.print("P"+i+"  ");
for (int k = 0; k < 3; k++){
System.out.print(Work[k]+"  ");
}
System.out.print("|  ");
for (int j = 0; j<3;j++){
Work[j]+=Alloction[i][j];
}
Finish[i]=true;//当当前进程能满足时
S[count]=i;//设置当前序列排号

count++;//满足进程数加1
for(int j=0;j<3;j++){
System.out.print(Alloction[i][j]+"  ");
}
System.out.print("|  ");
for(int j=0;j<3;j++){
System.out.print(Need[i][j]+"  ");
}
System.out.print("|  ");
for(int j=0;j<3;j++){
System.out.print(Work[j]+"  ");
}
System.out.println();
}

}
circle++;//循环圈数加1

if(count==flag){//判断是否满足所有进程需要
System.out.print("此时存在一个安全序列：");
for (int i = 0; i<flag;i++){//输出安全序列
System.out.print("P"+S[i]+" ");
}
System.out.println("故当前可分配！");
break;//跳出循环
}
if(count<circle){//判断完成进程数是否小于循环圈数
count=5;
System.out.println("当前系统处于不安全状态，故不存在安全序列。");
break;//跳出循环
}
}
}
}

### BankTest.java 测试类

import java.util.Scanner;

public class BankTest {
public static void main(String[] args) {
boolean Choose = true;
String C;
Scanner in = new Scanner(System.in);
Banker T = new Banker();
//        System.out.println("这是一个三个进程，初始系统可用三类资源为{10,8,7}的银行家算法：");
System.out.println("请输入进程的个数");
int count =in.nextInt();
T.count(count);
T.setSystemVariable();
while (Choose == true) {
T.setRequest();
System.out.println("您是否还要进行请求：y/n?");
C = in.nextLine();
if (C.endsWith("n")) {
Choose = false;
}
}
}
}

### 测试结果：

更多相关内容
• 操作系统银行家算法，C语言。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
• 简单模拟银行家算法，实现了银行家算法的模拟，具有小规模学习的作用
• 操作系统 银行家算法的详细实验报告，里面附有代码，可运行，图形化界面展示算法过程
• 操作系统死锁部分 银行家算法的相关习题 ，题目包括“ 某系统采用银行家算法分配三类资源A、B和C ......”
• 【计算机专业】操作系统 银行家算法详解
• 计算机操作系统银行家算法java代码，
• 算法流程图，运行环境和编程工具，模块划分及关系，模板流程图，程序源代码，测试结果
• 设计一个n个并发进程共享m个系统资源的程序以实现银行家算法。要求： 1） 简单的选择界面； 2） 能显示当前系统资源的占用和剩余情况。 3） 为进程分配资源，如果进程要求的资源大于系统剩余的资源，不与分配并且...
• 银行家算法避免死锁，实现系统合理分配资源，加深对进程同步及死锁理解。
• 操作系统银行家算法，可以直接运行，带注释，交作业非常方便
• 银行家算法是一种用来避免操作系统死锁出现的有效算法，银行家算法，可以了解死锁的概念。死锁：是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都...
• 是一个模拟银行家算法操作系统程序，采用JAVA16编写，有图形化界面GUI。包括对各种情况的检查安全序列、资源的分配和收回，m种资源n个进程，实时显示系统剩余资源量等
• 实验五 银行家算法 一实验目的和要求 理解死锁概念银行家算法及安全检测算法 在Linux操作系统下用C++进行编程 利用C++设计实现银行家算法的基本过程 验证银行家算法对于避免死锁的作用 二实验方法内容 算法设计思路 ...
• c语言实现操作系统作业银行家算法，算法不是很复杂相信理解了算法就可以写的出来。其实代码还有些不足，望自行下去改进。 使用方法：编译后运行程序，输入保存文件绝对路径，一般在txt下，查看文件结果
• 操作系统银行家算法带简单界面
• 操作系统作业内容全面下载就可交作业
• 银行家算法资源分配模拟器C++源文件，用于大学操作系统实验课代码的参考。
• 通过实例模拟银行家算法实现死锁预防，即输入实例数据后，能够使用银行家算法判断资源分配后是否存在安全序列。
• 大三上学期的操作系统课程的实验作业，要求模拟实现银行家算法。代码格式良好，注释得当，可供有需要的人参考学习。
• 代码主体非原创，测试中出现问题经过本人修改后上传，原资源来源：https://blog.csdn.net/houchaoqun_xmu/article/details/55540792 ...可以实现银行家算法检测安全序列避免死锁。此代码VS2010下可直接使用。
• Request i 是进程Pi 的请求...4．系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。如果安全才正式将资源分配给进程Pi，以完成本次分配；否则，将试探分配作废，恢复原来的资源分配状态，让进程Pi等待。

...