银行家算法
一．程序说明：
本算法有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 秒）
声明：
此程序为本人（java初学者）一个下午做出，虽不是很完美，但核心算法问题已解决，希望和大家多多交流。
加载中，请稍候......
加载中…
喜欢