使用java實(shí)現(xiàn)銀行家算法的示例

小編給大家分享一下使用java實(shí)現(xiàn)銀行家算法的示例，相信大部分人都還不怎么了解，因此分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后大有收獲，下面讓我們一起去了解一下吧！

具體內(nèi)容如下

題目：

初始時，Allocate[i,j]=0，表示初始時沒有進(jìn)程得到任何資源。假定進(jìn)程對資源的請求序
列為：

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 算法判斷每一次資源請求是否接受，如果接受請求，請給出請求接受后的資
源分配狀態(tài)，即 Allocate 矩陣、Need 矩陣和 Available 向量。

大致思路：

（1）：判斷該進(jìn)程資源請求是否小于Need需求矩陣,小于則進(jìn)第二步
（2）：判斷該進(jìn)程資源請求向量是否小于剩余資源向量Available，小于則進(jìn)入第三步
（3）：備份下資源狀態(tài)矩陣，假設(shè)接收該需求，求出相應(yīng)的資源狀態(tài)矩陣，需求矩陣，剩余資源向量
（4）：判斷接收請求后的狀態(tài)是否是安全狀態(tài)
A：初始該狀態(tài)下的進(jìn)程標(biāo)識都為false，work為資源剩余向量
B；循環(huán)該狀態(tài)下的進(jìn)程，如果滿足標(biāo)識為false，并且該進(jìn)程的需求向量小于work 則進(jìn)入C，當(dāng)循環(huán)完畢都沒有滿足條件的進(jìn)入D。
C：work+Allocate（對應(yīng)進(jìn)程的狀態(tài)），將該進(jìn)程對應(yīng)的進(jìn)程狀態(tài)標(biāo)識為true，將B的循環(huán)數(shù)變?yōu)?，從頭開始循環(huán)（進(jìn)入B）
D：循環(huán)遍歷該狀態(tài)下的進(jìn)程標(biāo)識，如果都為true則判斷狀態(tài)安全，否則判斷狀態(tài)不安全
（5）：如果狀態(tài)是安全的輸入該狀態(tài)下的各個矩陣與向量，如果不安全，則利用剛剛備份的資源狀態(tài)矩陣，回滾。

運(yùn)行截圖：

源代碼

package Banker;

public class Banker {
 public static int N = 4;// 線程個數(shù)
 public static int M = 3;// 資源個數(shù)
 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();
 //請求序列數(shù)組，包含第幾個請求，那條進(jìn)程，請求資源向量。
 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ìn)程
 * j第幾個請求
 */
 ban.judgeqingqiu(re[j][1], re[j][0][0]-1, j);//輸入第幾條進(jìn)程，請求向向量，第幾個請求，調(diào)用判斷是否符合要求函數(shù) 
 }
 
 
 }


 //判斷請求是否符合要求
 public void judgeqingqiu(int[] Request, int i,int j) {
 /*judgementrequest(Request, i)調(diào)用函數(shù)，判斷該進(jìn)程請求向量是否小于請求矩陣中對應(yīng)的向量請求資源
 * judgementrequest(Request, i)調(diào)用函數(shù)，判斷該進(jìn)程請求向量是否小于剩于資源向量
 */
 if (judgementrequest(Request, i) && judgementrequest(Request, i)) {
 distribute(Request,i);//調(diào)用假設(shè)分配函數(shù)，并將分配狀態(tài)copy出來
 //judgementsafe(Allocate)判斷是否是安全狀態(tài)
 if (judgementsafe(Allocate)) {
 
 System.out.println("############");
 System.out.println("第"+(j+1)+"個請求"+"進(jìn)程"+(i+1)+"請求資源被允許");
 printJuzhen("Allocate", Allocate);
 printJuzhen("Need", Need);
 PrintXianglaing("Available", Available);
 } else {
 System.out.println("############");
 System.out.println("第"+(j+1)+"個請求"+"進(jìn)程"+(i+1)+"請求資源被拒絕");
 erWeiCopy(Allocate, state);
 }
 } else {
 System.out.println("*****************");
 System.out.println("第"+(j+1)+"個請求"+"進(jìn)程"+(i+1)+"請求資源被拒絕");
 }
 }

 // 假設(shè)符合，分配資源，記錄下剩余資源
 public void distribute(int[] Request,int i) {

 state = erWeiCopy(state, Allocate);//將資源分配矩陣保留下來，如果不正確方便回滾
 Allocate = addrequest(Allocate, Request, i);//分配后的資源分配矩陣
 Need = reducerequest(Need, Allocate);//分配后的資源需求矩陣
 Available = AvaileReduceRequest(Available, Allocate);//分配后的資源剩余矩陣
 }
 
 // 判斷狀態(tài)安全函數(shù)
 public boolean judgementsafe(int[][] Allocate) {
 int[] work = new int[M];//相當(dāng)于標(biāo)記變量，標(biāo)識進(jìn)程是否符合，如果符合為true
 work = yiweicopy(work, Available);//將剩余資源響亮copy到work中
 boolean safe = true;//安全狀態(tài)，默認(rèn)為true
 Boolean[] finish = { false, false, false, false };//相當(dāng)于標(biāo)記變量，標(biāo)識進(jìn)程是否符合，如果符合為true，初始值都為false
 //循環(huán)遍歷該狀態(tài)中的進(jìn)程，判斷進(jìn)程的資源需求是否小于剩余資源數(shù)
 for (int j = 0; j < N; j++) {
 //進(jìn)程資源請求是否小于剩余資源work，并且該進(jìn)程標(biāo)識為false，
 if (judgementsafeWork(Need[j], work) && finish[j] == false) {
  finish[j] = true;//，將該進(jìn)程標(biāo)識為true，改變work
  for (int h = 0; h < M; h++) {
  work[h] = work[h] + Allocate[j][h];
  }
  j = -1;//，將j=0，再次從頭遍歷查看進(jìn)程
 }
 }
 /*
 * 當(dāng)沒有進(jìn)程滿足資源請求是否小于剩余資源work，并且該進(jìn)程標(biāo)識為false時
 * 遍歷狀態(tài)數(shù)組，看是否都為true
 */
 for (int m = 0; m < N; m++) {
 if (finish[m] == false) {
  safe = false;//如果狀態(tài)數(shù)組中有false那么將safe設(shè)置為false
 }
 }
 return safe;
 }

 // 判斷狀態(tài)是否安全時進(jìn)程資源請求是否小于剩余資源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;//返回狀態(tài)

 }

 
 // 判斷該進(jìn)程請求向量是否小于請求矩陣中對應(yīng)的向量請求資源
 public boolean judgementrequest(int[] Request, int i) {
 
 for (int j = 0; j < M; j++) {
 if (Request[j] > Need[i][j]) {
 return false;
 }
 }
 
 return true;
 }

 // 判斷該進(jìn)程請求向量是否小于剩于資源向量
 public boolean judgementAvali(int[] Request) {
 for (int j = 0; j < M; j++) {
 if (Request[j] >Available[j]) {
 return false;
 }
 }
 return true;

 }

 // 假設(shè)分配后修改資源分配矩陣
 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;

 }

 // 假設(shè)分配后修改資源的需求矩陣
 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;
 }

 // 假設(shè)分配后修改資源剩余矩陣
 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;
 }
 
 // 二維數(shù)組拷貝
 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;
 }

 // 一維數(shù)組拷貝
 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();
 }
 }

}

以上是“使用java實(shí)現(xiàn)銀行家算法的示例”這篇文章的所有內(nèi)容，感謝各位的閱讀！相信大家都有了一定的了解，希望分享的內(nèi)容對大家有所幫助，如果還想學(xué)習(xí)更多知識，歡迎關(guān)注億速云行業(yè)資訊頻道！