java实现简单银行家算法

网友投稿 457 2022-12-18


java实现简单银行家算法

本文实例为大家分享了java实现银行家算法的具体代码,供大家参考,具体内容如下

题目:

初始时,Allocate[i,j]=0,表示初始时没有进程得到任何资源。假定进程对资源的请求序

列为:

Request(1)[M]=(1,0,0);

Request(2)[M]=(2,1,0);

Request(2)[M]=(2,0,1);

Request(3)[M]=(2,1,1);

Request(4)[M]=(0,0,2);

Request(2)[M]=(1,0,1);

Request(1)[M]=(1,0,1);

请用 Banker 算法判断每一次资源请求是否接受,如果接受请求,请给出请求接受后的资

源分配状态,即 Allocate 矩阵、Need 矩阵和 Available 向量。

大致思路:

(1):判断该进程资源请求是否小于Need需求矩阵,小于则进第二步

(2):判断该进程资源请求向量是否小于剩余资源向量Available,小于则进入第三步

(3):备份下资源状态矩阵,假设接收该需求,求出相应的资源状态矩阵,需求矩阵,剩余资源向量

(4):判断接收请求后的状态是否是安全状态

A:初始该状态下的进程标识都为false,work为资源剩余向量

B;循环该状态下的进程,如果满足标识为false,并且该进程的需求向量小于work 则进入C,当循环完毕都没有满足条件的进入D。

C:work+Allocate(对应进程的状态),将该进程对应的进程状态标识为true,将B的循环数变为0,从头开始循环(进入B)

D:循环遍历该状态下的进程标识,如果都为true则判断状态安全,否则判断状态不安全

(5):如果状态是安全的输入该状态下的各个矩阵与向量,如果不安全,则利用刚刚备份的资源状态矩阵,回滚。

运行截图:

源代码

package Banker;

public class Banker {

public static int N = 4;// 线程个数

public static int M = 3;// 资源个数

public static int[] Resource = { 9, 3, 6 };// 资源向量;

public static int[][] Cliam = { { 3, 2, 2 }, { 6, 1, 3 }, { 3, 1, 4 }, { 4, 2, 2 } };

public static int[][] Allocate = new int[N][M];

public static int[][] Need = { { 3, 2, 2 }, { 6, 1, 3 }, { 3, 1, 4 }, { 4, 2, 2 } };

public static int[] Available = { 9, 3, 6 };

public int[][] state = new int[N][M];

public static void main(String args[]) {

Banker ban = new Banker();

//请求序列数组,包含第几个请求,那条进程,请求资源向量。

int[][][] re={{{1},{1,0,0}},{{2},{2,1,0}},{{2},{2,0,1}},{{3},{2,1,1}},{{4},{0,0,2}},{{2},{1,0,1}},{{1},{1,0,1}}};

for(int j=0;j

/*

* re[j][1] 请求向量

* re[j][0][0]-1 第几个进程

* j第几个请求

*/

ban.judgeqingqiu(re[j][1], re[j][0][0]-1, j);//输入第几条进程,请求向向量,第几个请求,调用判断是否符合要求函数

}

}

//判断请求是否符合要求

public void judgeqingqiu(int[] Request, int i,int j) {

/*judgementrequest(Request, i)调用函数,判断该进程请求向量是否小于请求矩阵中对应的向量请求资源

* judgementrequest(Request, i)调用函数,判断该进程请求向量是否小于剩于资源向量

*/

if (judgementrequest(Request, i) && judgementrequest(Request, i)) {

distribute(Request,i);//调用假设分配函数,并将分配状态copy出来

//judgementsafe(Allocate)判断是否是安全状态

if (judgementsafe(Allocate)) {

System.out.println("############");

System.out.println("第"+(j+1)+"个请求"+"进程"+(i+1)+"请求资源被允许");

printJuzhen("Allocate", Allocate);

printJuzhen("Need", Need);

PrintXianglaing("Available", Available);

} else {

System.out.println("############");

System.out.println("第"+(j+1)+"个请求"+"进程"+(i+1)+"请求资源被拒绝");

erWeiCopy(Allocate, state);

}

} else {

System.out.println("*****************");

System.out.println("第"+(j+1)+"个请求"+"进程"+(i+1)+"请求资源被拒绝");

}

}

// 假设符合,分配资源,记录下剩余资源

public void distribute(int[] Request,int i) {

state = erWeiCopy(state, Allocate);//将资源分配矩阵保留下来,如果不正确方便回滚

Allocate = addrequest(Allocate, Request, i);//分配后的资源分配矩阵

Need = reducerequest(Need, Allocate);//分配后的资源需求矩阵

Available = AvaileReduceRequest(Available, Allocate);//分配后的资源剩余矩阵

}

// 判断状态安全函数

public boolean judgementsafe(int[][] Allocate) {

int[] work = new int[M];//相当于标记变量,标识进程是否符合,如果符合为true

work = yiweicopy(work, Available);//将剩余资源响亮copy到work中

boolean safe = true;//安全状态,默认为true

Boolean[] finish = { false, false, false, false };//相当于标记变量,标识进程是否符合,如果符合为true,初始值都为false

//循环遍历该状态中的进程,判断进程的资源需求是否小于剩余资源数

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

//进程资源请求是否小于剩余资源work,并且该进程标识为false,

if (judgementsafeWork(Need[j], work) && finish[j] == false) {

finish[j] = true;//,将该进程标识为true,改变work

for (int h = 0; h < M; h++) {

work[h] = work[h] + Allocate[j][h];

}

j = -1;//,将j=0,再次从头遍历查看进程

}

}

/*

* 当没有进程满足资源请求是否小于剩余资源work,并且该进程标识为false时

* 遍历状态数组,看是否都为true

*/

for (int m = 0; m < N; m++) {

if (finish[m] == false) {

safe = false;//如果状态数组中有false那么将safe设置为false

}

}

return safe;

}

// 判断状态是否安全时进程资源请求是否小于剩余资源work

public boolean judgementsafeWork(int[] Request, int[] work) {

for (int k = 0; k < M; k++) {

// PrintXianglaing("",Request);

if (Request[k] >work[k]) {

return false;

}

}

return true;//返回状态

}

// 判断该进程请求向量是否小于请求矩阵中对应的向量请求资源

public boolean judgementrequest(int[] Request, int i) {

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

if (Request[j] > Need[i][j]) {

return false;

}

}

return true;

}

// 判断该进程请求向量是否小于剩于资源向量

public boolean judgementAvali(int[] Request) {

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

if (Request[j] >Available[j]) {

return false;

}

}

return true;

}

// 假设分配后修改资源分配矩阵

public int[][] addrequest(int[][] Allocate, int[] Request, int i) {

for (int h = 0; h < M; h++) {

Allocate[i][h] = Allocate[i][h] + Request[h];

}

return Allocate;

}

// 假设分配后修改资源的需求矩阵

public int[][] reducerequest(int[][] Need, int[][] state) {

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

for (int h = 0; h < M; h++) {

Need[j][h] = Cliam[j][h] - state[j][h];

}

}

return Need;

}

// 假设分配后修改资源剩余矩阵

public int[] AvaileReduceRequest(int[] Available, int[][] Allocate) {

Available = yiweicopy(Available, Resource);

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

for (int h = 0; h < M; h++) {

Available[h] = Available[h] - Allocate[j][h];

}

}

return Available;

}

// 二维数组拷贝

public int[][] erWeiCopy(int[][] x1, int[][] y1) {

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

for (int h = 0; h < M; h++) {

x1[j][h] = y1[j][h];

}

}

return x1;

}

// 一维数组拷贝

public int[] yiweicopy(int[] x1, int[] y1) {

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

x1[j] = y1[j];

}

return x1;

}

// 打印向量

public static void PrintXianglaing(String id, int[] x) {

System.out.println(id);

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

System.out.print(x[j] + " ");

}

System.out.println("");

}

// 打印矩阵

public static void printJuzhen(String id, int[][] y) {

System.out.println(id);

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

for (int h = 0; h < M; h++) {

System.out.print(y[j][h] + " ");

}

System.out.println();

}

}

}

/*

* re[j][1] 请求向量

* re[j][0][0]-1 第几个进程

* j第几个请求

*/

ban.judgeqingqiu(re[j][1], re[j][0][0]-1, j);//输入第几条进程,请求向向量,第几个请求,调用判断是否符合要求函数

}

}

//判断请求是否符合要求

public void judgeqingqiu(int[] Request, int i,int j) {

/*judgementrequest(Request, i)调用函数,判断该进程请求向量是否小于请求矩阵中对应的向量请求资源

* judgementrequest(Request, i)调用函数,判断该进程请求向量是否小于剩于资源向量

*/

if (judgementrequest(Request, i) && judgementrequest(Request, i)) {

distribute(Request,i);//调用假设分配函数,并将分配状态copy出来

//judgementsafe(Allocate)判断是否是安全状态

if (judgementsafe(Allocate)) {

System.out.println("############");

System.out.println("第"+(j+1)+"个请求"+"进程"+(i+1)+"请求资源被允许");

printJuzhen("Allocate", Allocate);

printJuzhen("Need", Need);

PrintXianglaing("Available", Available);

} else {

System.out.println("############");

System.out.println("第"+(j+1)+"个请求"+"进程"+(i+1)+"请求资源被拒绝");

erWeiCopy(Allocate, state);

}

} else {

System.out.println("*****************");

System.out.println("第"+(j+1)+"个请求"+"进程"+(i+1)+"请求资源被拒绝");

}

}

// 假设符合,分配资源,记录下剩余资源

public void distribute(int[] Request,int i) {

state = erWeiCopy(state, Allocate);//将资源分配矩阵保留下来,如果不正确方便回滚

Allocate = addrequest(Allocate, Request, i);//分配后的资源分配矩阵

Need = reducerequest(Need, Allocate);//分配后的资源需求矩阵

Available = AvaileReduceRequest(Available, Allocate);//分配后的资源剩余矩阵

}

// 判断状态安全函数

public boolean judgementsafe(int[][] Allocate) {

int[] work = new int[M];//相当于标记变量,标识进程是否符合,如果符合为true

work = yiweicopy(work, Available);//将剩余资源响亮copy到work中

boolean safe = true;//安全状态,默认为true

Boolean[] finish = { false, false, false, false };//相当于标记变量,标识进程是否符合,如果符合为true,初始值都为false

//循环遍历该状态中的进程,判断进程的资源需求是否小于剩余资源数

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

//进程资源请求是否小于剩余资源work,并且该进程标识为false,

if (judgementsafeWork(Need[j], work) && finish[j] == false) {

finish[j] = true;//,将该进程标识为true,改变work

for (int h = 0; h < M; h++) {

work[h] = work[h] + Allocate[j][h];

}

j = -1;//,将j=0,再次从头遍历查看进程

}

}

/*

* 当没有进程满足资源请求是否小于剩余资源work,并且该进程标识为false时

* 遍历状态数组,看是否都为true

*/

for (int m = 0; m < N; m++) {

if (finish[m] == false) {

safe = false;//如果状态数组中有false那么将safe设置为false

}

}

return safe;

}

// 判断状态是否安全时进程资源请求是否小于剩余资源work

public boolean judgementsafeWork(int[] Request, int[] work) {

for (int k = 0; k < M; k++) {

// PrintXianglaing("",Request);

if (Request[k] >work[k]) {

return false;

}

}

return true;//返回状态

}

// 判断该进程请求向量是否小于请求矩阵中对应的向量请求资源

public boolean judgementrequest(int[] Request, int i) {

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

if (Request[j] > Need[i][j]) {

return false;

}

}

return true;

}

// 判断该进程请求向量是否小于剩于资源向量

public boolean judgementAvali(int[] Request) {

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

if (Request[j] >Available[j]) {

return false;

}

}

return true;

}

// 假设分配后修改资源分配矩阵

public int[][] addrequest(int[][] Allocate, int[] Request, int i) {

for (int h = 0; h < M; h++) {

Allocate[i][h] = Allocate[i][h] + Request[h];

}

return Allocate;

}

// 假设分配后修改资源的需求矩阵

public int[][] reducerequest(int[][] Need, int[][] state) {

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

for (int h = 0; h < M; h++) {

Need[j][h] = Cliam[j][h] - state[j][h];

}

}

return Need;

}

// 假设分配后修改资源剩余矩阵

public int[] AvaileReduceRequest(int[] Available, int[][] Allocate) {

Available = yiweicopy(Available, Resource);

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

for (int h = 0; h < M; h++) {

Available[h] = Available[h] - Allocate[j][h];

}

}

return Available;

}

// 二维数组拷贝

public int[][] erWeiCopy(int[][] x1, int[][] y1) {

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

for (int h = 0; h < M; h++) {

x1[j][h] = y1[j][h];

}

}

return x1;

}

// 一维数组拷贝

public int[] yiweicopy(int[] x1, int[] y1) {

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

x1[j] = y1[j];

}

return x1;

}

// 打印向量

public static void PrintXianglaing(String id, int[] x) {

System.out.println(id);

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

System.out.print(x[j] + " ");

}

System.out.println("");

}

// 打印矩阵

public static void printJuzhen(String id, int[][] y) {

System.out.println(id);

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

for (int h = 0; h < M; h++) {

System.out.print(y[j][h] + " ");

}

System.out.println();

}

}

}


版权声明:本文内容由网络用户投稿,版权归原作者所有,本站不拥有其著作权,亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容,请联系我们jiasou666@gmail.com 处理,核实后本网站将在24小时内删除侵权内容。

上一篇:springboot自定义异常视图过程解析
下一篇:基于SPRINGBOOT配置文件占位符过程解析
相关文章

 发表评论

暂时没有评论,来抢沙发吧~