java实现银行家算法

实验名称 银行家算法

一、实验目的

用高级语言编写和调试一个银行家算法程序，并可以利用银行家算法模拟分配资源以及进行安全性检查。加深对银行家算法的理解。

二、实验指导

1. 银行家算法中的数据结构

(1) 可利用资源向量Available。这是一个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目，其初始值是系统中所配置的该类全部可用资源的数目，其数值随该类资源的分配和回收而动态地改变。如果Available［j］=K，则表示系统中现有Rj类资源K个。

(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］ 2. 银行家算法

设Requesti是进程Pi的请求向量，如果Requesti［j］=K，表示进程Pi需要K个Rj类型的资源。当Pi

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

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

(3) 系统试探着把资源分配给进程Pi

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

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

(4) 系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。若安全，才正式将资源分配给进程Pi，以完成本次分配；否则， 将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。 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］∶= Finish［i］∶= go to step 2;

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

Work［i］+Allocation［i,j］;true;

三、提示

可以用下面的数据作为测试数据

假定系统中有五个进程｛P0, P1, P2, P3, P4｝和三类资源｛A, B, C｝，各种资源的数量分别为10、5、7，在T0时刻的资源分配情况如图2-1 所示。

图

2-1 T0时刻的资源分配表

请求序列

（1）P1发出请求向量Request1(1，0，2) （2）P4发出请求向量Request4(3，3，0) （3）P0发出请求向量Requst0(0，2，0)

附源代码：

import java.util.Scanner;

public class BankerCalculate { public static int p[];//进程数量

public static int Sourse[];//系统各种资源的总量 public static int Max[][]; // 最大需求矩阵 public static int Allocation[][];// 每个进程现在所分配的各种资源类型的实例数量 public static int Available[]; // 可利用资源向量，即每种资源的现有实例数 public static int Need[][]; // 每个进程还需要的剩余资源 public static int Work[]; // 系统可供给进程的各类资源数量 public static int _Work[][];//存放每一次分配资源前的Work public static boolean Finish[]; // 标志一个进程是否可以得到其所需要是资源 public static int Request[]; // 进程对每个资源的实例数的请求数量 public static int flag = 0; BankerCalculate() { Sourse = new int[] { 10, 5, 7 }; Max = new int[][] { { 7, 5, 3 }, { 3, 2, 2 }, { 9, 0, 2 }, { 2, 2, 2 }, { 4, 3, 3 } }; Allocation = new int[][] { { 0, 1, 0 }, { 2, 0, 0 }, { 3, 0, 2 }, { 2, 1, 1 }, { 0, 0, 2 } }; Available = new int[Sourse.length]; Need = new int[Max.length][Sourse.length]; for (int m = 0; m < 3; m++) Available[m] = Sourse[m] - Allocation[0][m] - Allocation[1][m] - Allocation[2][m] - Allocation[3][m] - Allocation[4][m]; for (int i = 0; i < 5; i++) //计算need的值 for (int j = 0; j < 3; j++) Need[i][j] = Max[i][j] - Allocation[i][j]; p = new int[100]; Work = new int[100]; _Work = new int[100][100]; Request = new int[100]; Finish = new boolean[100]; BankerCalculate.Print(-1); } public static void Print(int p) { if (p == -1) { System.out.println(\初始资源分配情况--------------------------\ System.out.println(\ Max Allocation Need Available\

System.out.println(\ A B C A B C A B C A B C\ System.out.print(\ \ for (int j = 0; j < 3; j++) System.out.print(Max[0][j] + \ \ System.out.print(\ \ for (int j = 0; j < 3; j++) System.out.print(Allocation[0][j] + \ \ System.out.print(\ \ for (int j = 0; j < 3; j++) System.out.print(Need[0][j] + \ \ System.out.print(\ \ for (int j = 0; j < 3; j++) System.out.print(Available[j] + \ \ System.out.println(); for (int i = 1; i < 5; i++) { System.out.print(\ \ 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(Allocation[i][j] + \ \ System.out.print(\ \ for (int j = 0; j < 3; j++) System.out.print(Need[i][j] + \ \ System.out.println(); } }else { if (flag == 0) { System.out.println(\请求资源后分配情况--------------------------\ System.out.println(\ Work Need Allocation Work+Allocation Finish\ System.out.println(\ A B C A B C A B C A B C\ flag = 1; } if (flag == 1) { System.out.print(\ \ for (int j = 0; j < 3; j++) System.out.print(_Work[p][j] + \ \ System.out.print(\ \ for (int j = 0; j < 3; j++) System.out.print(Need[p][j] + \ \

System.out.print(\ \ for (int j = 0; j < 3; j++) System.out.print(Allocation[p][j] + \ \ System.out.print(\ \ for (int j = 0; j < 3; j++) System.out.print((_Work[p][j]+Allocation[p][j]) + \ \ System.out.print(\ \ System.out.println(); } } }

public static boolean can(int a[][], int i, int b[]) { int j; for (j = 0; j < Sourse.length; j++) { if (a[i][j] > b[j]) return false; } return true; }

public static boolean Security_check() { boolean run = true; int count = 0,procedure = 0;

for (int j = 0; j < Sourse.length; j++)//对work进行初始化 Work[j] = Available[j];

for (int m = 0; m < Max.length; m++)//对finish进行初始化

Finish[m] = false; while (run) { for (int i = 0; i < Max.length; i++) { count++; if (Finish[i] == false && can(Need, i, Work) == true) { count--; Finish[i] = true; p[procedure] = i; procedure++; for(int j = 0; j < Sourse.length; j++) _Work[i][j] = Work[j]; for (int j = 0; j < Sourse.length; j++) { Work[j] = Work[j] + Allocation[i][j]; } } } if(count==Max.length) { run=false; }

else { run = true; count=0; } } for (int i = 0; i < Max.length; i++) if (Finish[i] == false) { System.out.println(\找不到一个安全序列,系统处于不安全状态。\ return false; }

System.out.println(\存在一个安全序列，系统处于安全状态，可为其分配资源。\ return true; }

public static void SourseRequest() { boolean run = true,run1 = true; while(run) { Scanner s = new Scanner(System.in);

System.out.println(\第几个进程需要请求资源？\int id = s.nextInt() - 1;

if(id < 0 || id >= Max.length) {

System.out.println(\不存在此进程！请重新输入。\}else { while(run1) { run = false; int count = 0;

System.out.println(\请依次输入此进程所请求的每类资源数：\for(int i = 0; i < Sourse.length; i++) { Scanner a = new Scanner(System.in); Request[i] = a.nextInt(); }

for(int i = 0; i < Sourse.length; i++) { if(Request[i] > Need[id][i]) {

System.out.println(\第\类资源请求量超出最大值！无

效。\

count++;

} } if(count > 0) run1 = true; if(count == 0) { run1 = false; for (int k = 0;k

Allocation[id][k] = Allocation[id][k] + Request[k];

}

Need[id][k] = Need[id][k] - Request[k]; } } } } } }

public static void Distribution() { if(Security_check()) for(int i =0 ; i < Max.length;i++) BankerCalculate.Print(p[i]); }

public static void main(String[] args) { new BankerCalculate(); BankerCalculate.SourseRequest(); BankerCalculate.Distribution(); }

本文来源：https://www.bwwdw.com/article/dbw5.html