java 银行家算法_求JAVA语言的银行家算法

展开全部

银行家算法62616964757a686964616fe78988e69d8331333264663634

一．程序说明：

本算法有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

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 秒)

已赞过

已踩过<

你对这个回答的评价是？

评论

收起