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.length;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();
 }
 }

}

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • java实现银行家算法

    本文实例为大家分享了java实现银行家算法的具体代码,供大家参考,具体内容如下 import java.util.Arrays; import javax.swing.JOptionPane; public class Banker_Dijkstra { static int available[]={3,3,2}; //可利用资源数 static int max[][]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};; //每线程最大需求 static i

  • java实现银行家算法(Swing界面)

    java代码实现了银行家算法,界面写的个人认为还是较为细致的,完整的实现了找安全序列等算法功能,可作为参考学习银行家算法. 直接上代码:①界面展示方法: public void ShowFrame() { this.setSize(500, 350); //大小 this.setAlwaysOnTop(true); this.setResizable(false);//不可拖动 this.setLayout(new BorderLayout()); this.setTitle("lly_bank

  • 使用java实现银行家算法

    银行家算法核心 先寻找满足系统当前剩余的资源量(avaliable )>=进程运行所需的资源数的进程(need),再假设这个进程安全校验是成功的,当这个进程运行完毕后,释放资源后,现在系统当前剩余的资源(avaliable)=avaliable+该线程之前已分配的资源(allocation) ,将该节点进程设为处理时忽略进程,再以上条件为前提进行安全校验. 安全校验:一个进程获得资源后,运行完毕,释放之前分配的资源,其他的线程可以继续运行,而不会造成死锁. 这样就会产生回溯. 满足条件:是否存在

  • 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

  • JAVA实现简单抢红包算法(模拟真实抢红包)

    闲来无事,最近项目需求要写出用户登录首页来发现金红包,没有限额.我就自己稍微计算了一下如果有限额该怎么写.觉得这样与微信红包差不多.等项目需求完成以后.正好来博客贴一下我自己写的拆红包算法.个人觉得这个算法比较模拟现实抢红包规则.废话少说.先贴代码; import java.math.BigDecimal; import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.ut

  • Java实现的两种常见简单查找算法示例【快速查找与二分查找】

    本文实例讲述了Java实现的两种常见简单查找算法.分享给大家供大家参考,具体如下: 前言: 查找是指从一批记录当中找出满足制定条件的某一记录的过程. 在平常的程序的编写当中很多时候时用得上的,这里简单介绍两个查找算法 1. 快速查找: 这个是相当简单的,以数组举例,就用一个for循环去查找数组中需要查找的数据 例子: public static boolean quickSearch(int a[], int x) { boolean f = false; int length = a.leng

  • 用Java实现小球碰壁反弹的简单实例(算法十分简单)

    核心代码如下: if(addX){ x+=3; }else{ x-=3; } if(addY){ y+=6; }else{ y-=6; } if(x<=0||x>=(width-50)){ addX=!addX; } if(y<=0||y>=(height-50)){ addY=!addY; } 根据x和y递增的值,来决定角度. 以上这篇用Java实现小球碰壁反弹的简单实例(算法十分简单)就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们.

  • 三种简单排序算法(使用java实现)

    一.冒泡排序 算法思想:遍历待排序的数组,每次遍历比较相邻的两个元素,如果他们的排列顺序错误就交换他们的位置,经过一趟排序后,最大的元素会浮置数组的末端.重复操 作,直到排序完成. 示例演示: 算法实现: for(int i=0;i<array.length-1;i++){//最多排序n-1次 for(int j=0;j<array.length-i-1;j++){//需要交换的次数 if(array[j]>array[j+1]){ int temp=array[j]; array[j]

  • java实现简单解析XML文件功能示例

    本文实例讲述了java实现简单解析XML文件功能.分享给大家供大家参考,具体如下: package demo; import java.io.File; import java.io.IOException; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.parsers.ParserConfigurationException;

  • Java实现简单修改文件名的方法分析

    本文实例讲述了Java实现简单修改文件名的方法.分享给大家供大家参考,具体如下: 今天帮朋些个网站,做到商品上传的时候需要给文件重新设置名称,以前也做过类的功能,只是没有保存忘了,为了避免以后再重新找,就在此记录下,哈哈..... 例子一: import java.io.*; public class test1 { public static void main(String[] args) { File file=new File("D:/gai.jpg"); //指定文件名及路径

随机推荐