Question

求JAVA语言的银行家算法

Answer 1

银行家算法

一．程序说明：

本算法有3个进程，3类资源。初始可用资源向量为Available{10,8,7}，然后设置各进程的最大需求矩阵MAX以及分配矩阵Alloction,由此算出需求矩阵Need。然后判断当前系统资源分配是否处于安全状态，否则结束进程。最后，在当前分配资源后的系统安全时，选择一进程，并请求各类所需资源矩阵Request，尝试分配并修改资源分配状况，判断此进程请求是否该分配，进而进入安全算法判断是否能形成一个安全序列，如果有则分配，否则不分配。

二．程序代码：

算法类：

package bankerclass;

import java.util.Scanner;

public class BankerClass {

int[] Available = {10, 8, 7};

int[][] Max = new int[3][3];

int[][] Alloction = new int[3][3];

int[][] Need = new int[3][3];

int[][] Request = new int[3][3];

int[] Work = new int[3];

int num = 0;//进程编号

Scanner in = new Scanner(System.in);

public BankerClass() {

// Max={{6,3,2},{5,6,1},{2,3,2}};

}

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

setMax();

setAlloction();

printSystemVariable();

SecurityAlgorithm();

}

public void setMax() {//设置Max矩阵

System.out.println("请设置各进程的最大需求矩阵Max：");

for (int i = 0; i < 3; 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 < 3; 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矩阵

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

Available[i] = Available[i] - Alloction[j][i];

}

}

for (int i = 0; i < 3; 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<3;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;

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

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[] Finish = {false, false, false};//初始化Finish

int count = 0;//完成进程数

int circle=0;//循环圈数

int[] S=new int[3];//安全序列

for (int i = 0; i < 3; i++) {//设置工作向量

Work[i] = Available[i];

}

System.out.println("进程 "+" Work "+" Alloction "+" Need "+"Work+Available ");

while (count < 3) {

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

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==3){//判断是否满足所有进程需要

System.out.print("此时存在一个安全序列：");

for (int i = 0; i<3;i++){//输出安全序列

System.out.print("P"+S[i]+" ");

}

System.out.println("故当前可分配！");

break;//跳出循环

}

if(count<circle){//判断完成进程数是否小于循环圈数

count=5;

System.out.println("当前系统处于不安全状态，故不存在安全序列。");

break;//跳出循环

}

}

}

}

主类：

package bankerclass;

import java.util.Scanner;

public class TestBankerClass {

public static void main(String[] args) {

// TODO code application logic here

boolean Choose = true;

String C;

Scanner in = new Scanner(System.in);

BankerClass T = new BankerClass();

System.out.println("这是一个三个进程，初始系统可用三类资源为{10,8,7}的银行家算法：");

T.setSystemVariable();

while (Choose == true) {

T.setRequest();

System.out.println("您是否还要进行请求：y/n?");

C = in.nextLine();

if (C.endsWith("n")) {

Choose = false;

}

}

}

}

三．随机运行过程

1.

run：

这是一个三个进程，初始系统可用三类资源为{10,8,7}的银行家算法：

请设置各进程的最大需求矩阵Max：

请输入进程P0的最大资源需求量：

8 7 5

请输入进程P1的最大资源需求量：

5 2 5

请输入进程P2的最大资源需求量：

6 6 2

请设置请各进程分配矩阵Alloction：

晴输入进程P0的分配资源量：

3 2 0

晴输入进程P1的分配资源量：

2 0 2

晴输入进程P2的分配资源量：

1 3 2

Available=Available-Alloction.

Need=Max-Alloction.

此时资源分配量如下：

进程 Max Alloction Need Available

P0 8 7 5 | 3 2 0 | 5 5 5 | 4 3 3

P1 5 2 5 | 2 0 2 | 3 2 3 |

P2 6 6 2 | 1 3 2 | 5 3 0 |

进程 Work Alloction Need Work+Available

P1 4 3 3 | 2 0 2 | 3 2 3 | 6 3 5

P2 6 3 5 | 1 3 2 | 5 3 0 | 7 6 7

P0 7 6 7 | 3 2 0 | 5 5 5 | 10 8 7

此时存在一个安全序列：P1 P2 P0 故当前可分配！

请输入请求资源的进程编号：

0

请输入请求各资源的数量：

1 0 0

即进程P0对各资源请求Request：(1,0,0).

此时资源分配量如下：

进程 Max Alloction Need Available

P0 8 7 5 | 4 2 0 | 4 5 5 | 3 3 3

P1 5 2 5 | 2 0 2 | 3 2 3 |

P2 6 6 2 | 1 3 2 | 5 3 0 |

现在进入安全算法：

进程 Work Alloction Need Work+Available

P1 3 3 3 | 2 0 2 | 3 2 3 | 5 3 5

P2 5 3 5 | 1 3 2 | 5 3 0 | 6 6 7

P0 6 6 7 | 4 2 0 | 4 5 5 | 10 8 7

此时存在一个安全序列：P1 P2 P0 故当前可分配！

您是否还要进行请求：y/n?

y

请输入请求资源的进程编号：

2

请输入请求各资源的数量：

0 1 0

即进程P2对各资源请求Request：(0,1,0).

此时资源分配量如下：

进程 Max Alloction Need Available

P0 8 7 5 | 4 2 0 | 4 5 5 | 3 2 3

P1 5 2 5 | 2 0 2 | 3 2 3 |

P2 6 6 2 | 1 4 2 | 5 2 0 |

现在进入安全算法：

进程 Work Alloction Need Work+Available

P1 3 2 3 | 2 0 2 | 3 2 3 | 5 2 5

P2 5 2 5 | 1 4 2 | 5 2 0 | 6 6 7

P0 6 6 7 | 4 2 0 | 4 5 5 | 10 8 7

此时存在一个安全序列：P1 P2 P0 故当前可分配！

您是否还要进行请求：y/n?

n

成功生成（总时间：1 分钟 38 秒）

Answer 2

package java_OS;

import java.util.Scanner;

public class Test
{
int no1, no2; //进程、资源个数
static int Max[][]; //最大需求
static int Allocation[][]; //已分配资源数
static int Need[][]; //仍需资源数
static int Available[]; //可利用资源数
static String name1[]; //进程名称
static String name2[]; //资源名称
static boolean[] Finish;
static int[] temp = { 0 }; //存放安全序列
static int work[];
static int[] Request;
Scanner input = new Scanner(System.in);

public static void main(String[] args) {
Test t = new Test();
t.printFrame();
//t.print();
t.Safty();
t.judge();
}

/* 输入初始化数据*/

public void printFrame()
{
System.out.println("*****************************************************");
System.out.println("* 银行家算法设计与实现 *");
System.out.println("* 学号： *");
System.out.println("* 姓名： *");
System.out.println("* *");
System.out.println("*****************************************************");
System.out.print("请输入系统中进程的个数:");
no1 = input.nextInt();
System.out.print("请输入资源的种类数：");
no2 = input.nextInt();
Max = new int[no1][no2];
Allocation = new int[no1][no2];
Need = new int[no1][no2];
Available = new int[no2];
name1 = new String[no1];
name2 = new String[no2];

//int sum[] = new int[3];
for (int i = 0; i < no1; i++)
{
System.out.print("请输入进程" + i + "的名字:");
name1[i] = input.next();
}
for (int i = 0; i < no2; i++)
{
System.out.print("请输入资源" + i + "的名字:");
name2[i] = input.next();
}
for (int i = 0; i < no1; i++)
{
System.out.print("请输入进程" + name1[i] + "的各类资源最大需求量:");
for (int j = 0; j < no2; j++)
{
Max[i][j] = input.nextInt();
}
}
for (int i = 0; i < no1; i++)
{
System.out.print("请输入进程" + name1[i] + "的各类资源已分配资源量:");
for (int j = 0; j < no2; j++)
{
Allocation[i][j] = input.nextInt();
Need[i][j] = Max[i][j] - Allocation[i][j];
}
}

for (int i = 0; i < no2; i++)
{
System.out.print("请输入" + name2[i] + "类资源的可利用资源数：");
Available[i] = input.nextInt();
}
//for (int i = 0; i < no2; i++)
// {Available[i] = Available[i] - sum[i];}
}

/**
* 打印输出
*/

public void print()
{
System.out.println("================此时刻资源分配情况================");
System.out.println(" Number Name Max Allocation Need");

for (int i = 0; i < no1; i++)
{
System.out.print( " "+ i +" ");
System.out.print(name1[i]+" ");
for (int j = 0; j < no2; j++)
{System.out.print(Max[i][j]+" ");}
System.out.print(" ");
for (int j = 0; j < no2; j++)
{System.out.print(" "+ Allocation[i][j]);}
System.out.print(" ");
for (int j = 0; j < no2; j++)
{System.out.print(" " + Need[i][j]);}

System.out.println();
}
System.out.print("各个类资源可利用的资源数分别为:");
for (int j = 0; j < no2; j++)
{System.out.print(" " + Available[j]);}
System.out.println();
}

/**
* 进行安全性检测
*/
public void Safty() {
Finish = new boolean[no1];
temp = new int[no1];
int i, k = 0, m, apply,j;//k为安全序列的序列数
int flag = 0;
work = new int[no2];
for (i = 0; i < no2; i++)
{work[i] = Available[i];}
for (i = 0; i < no1; i++) //当前执行换后，重第一个开始检测
{
apply = 0;
for (j = 0; j < no2; j++)
{
if (Finish[i] == false && Need[i][j] <= work[j]) //条件一二
{
apply++;
if (apply == no2)
{
for (m = 0; m < no2; m++)
work[m] = work[m] + Allocation[i][m];// 变分配数
Finish[i] = true;
temp[k] = i+1; //保存安全序列
i = -1; //从第一个进程开始继续寻找满足条件一二的进程
k++;
flag++;
}
}
}
}
for (i = 0; i < no2; i++)
{
if (Finish[i] == false) {System.out.println("系统不安全！");}
else
{
System.out.print("系统是安全的，安全序列为：");
for (i = 0; i < no1; i++) // 输出运行进程数组
{ System.out.print(temp[i] + "-->"); }
System.out.println();
print();

}

}
}

/* 进行资源分配 */

public void changdata(int i)
{
int j;
for (j = 0; j < no2; j++)
{
Available[j] = Available[j] - Request[j];
Allocation[i][j] = Allocation[i][j] + Request[j];
Need[i][j] = Need[i][j] - Request[j];
work[j] = Available[j];
}

}

/* *
* 利用银行家算法对申请资源对进行判定
*/
public void judge()
{
Request = new int[no2];
char ch='y';
int i = 0, j = 0;
System.out.print("请输入您要分配的资源进程号：");
for(j=0;j<10;j++)
{
i = input.nextInt();
if(i>no1)
{System.out.println("输入错误，请重新输入:");continue;}
else break;
}

System.out.println("请输入进程" + i + "申请的资源：");
for (j = 0; j < no2; j++)
{
System.out.print("请求"+name2[j] + "类资源数：");

Request[j] = input.nextInt();
}
for (j = 0; j < no2; j++)
{
if (Request[j] > Need[i][j]) // 判断申请是否大于需求，若大于则出错
{
System.out.println("进程" + i + "申请的资源大于它所需要的资源。");
System.out.println("分配不合理，不予分配！");
ch = 'n';
break;
}
else
{
if (Request[j] > Available[j])// 判断申请是否大于当前资源，若大于则出错
{
System.out.println("进程" + i + "申请的资源大于系统现在可利用的资源。");
System.out.println("分配不合理，不予分配！");
ch = 'n';
break;
}
}
}
if (ch == 'y')
{
changdata(i); // 根据进程需求量变换资源
Safty(); // 根据进程需求量进行银行家算法判断
}
System.out.println("请输入您所要进行的操作：1：继续分配 2：退出");
for(i=0;;i++)
{
int choice = input.nextInt();
if (choice == 1) judge();
else if (choice == 2) System.exit(0);
else System.out.print("输入选择错误，请重新选择：");
}
}
}

Answer 3

楼上正解~