对银行家算法的一种实现

/**
* 银行家算法，避免死锁
* 2014-9-12
* @author knight_coder
*
*/
public class Banker {
Banker banker = new Banker(4, 4);//4个进程：编号0-3；4种资源，编号0-3
//初始化系统资源数目
int available[] = new int[]{1,5,2,0};
int need[][] = new int[][]{{0,6,4,2},{0,5,1,0},{0,0,0,2},{0,7,5,0}};
int allocation[][] = new int[][]{{0,0,1,4},{1,4,3,2},{1,3,5,4},{1,0,0,0}};
banker.setAvailable(available);
banker.setNeed(need);
banker.setAllocation(allocation);
//判断是否发生死锁：给0号进程分配1号资源，数量是5
//结果：发生死锁
banker.judge(0, 1, 5);
//判断是否发生死锁：给0号进程分配1号资源，数量是5
//结果：不会发生死锁
banker.judge(1, 1, 5);

/**
* 构造函数
* @param threads 并发线程数
* @param resources 资源种类
*/
public Banker(int threads, int resources) {
this.threads = threads;
this.resources = resources;
allocation = new int[threads][resources];
need = new int[threads][resources];
available = new int[resources];
}
/**
* 初始化系统拥有的各类资源的数量
* @param i
* @param j
*/
public void initializeResources(int i, int j) {
available[i] = j;
}
/**
* 获取系统拥有的各类资源的数量
* @return
*/
public int[] getAvailable() {
return available;
}
/**
* 设置系统拥有的各类资源的数量
* @param available
*/
public void setAvailable(int[] available) {
this.available = available;
}
/**
* 返回每个线程已经获取的资源数
* @return
*/
public int[][] getAllocation() {
return allocation;
}
/**
* 设置每个线程已经获取的资源数
*/
public void setAllocation(int[][] allocation) {
this.allocation = allocation;
}
/**
* 获取每个进程还需要的资源数目
* @return
*/
public int[][] getNeed() {
return need;
}
/**
* 设置每个进程还需要的资源数目
* @param need
*/
public void setNeed(int[][] need) {
this.need = need;
}
/**
* 判断如果给进程i分配数量为mount的资源j，是否会发生死锁
* @param i
* @param j
* @return
*/
public boolean judge(int i, int j, int mount){
//创建数组副本
int need[][] = this.need.clone();
int allocation[][] = this.allocation.clone();
int available[] = this.available.clone();

if(need[i][j] < mount){
System.out.println("进程" + i + "不需要那么多资源" + j + "，分配失败");
return false;
}else if(available[j] < mount){
System.out.println("剩余的资源" + j + "数量不足，分配失败");
return false;
}else{
need[i][j] -= mount;//更新进程i需要资源j的数量
allocation[i][j] += mount;//更新已分配资源的数量
available[j] -= mount;//更新剩余资源数
boolean end = false;//判断循环是否结束
boolean success[]= new boolean[threads]; //进程是否可获得需要的全部资源。获取成功后，应释放已获取的全部资源

while(!end){
end = true;
for(int k = 0; k < threads; k++) {
if(success[k])//进程k已结束
continue;

int g = 0;
for(; g < resources; g++) {
if(need[k][g] > available[g])
break;
}
if(g == resources){//进程k可获得需要的全部资源
success[k] = true;//标识进程k已结束
end = false;
//获取成功后，应释放已获取的全部资源
for(g = 0; g < resources; g++)
available[g] += allocation[k][g];
}
}
}

for(boolean b : success){//如果有进程未能结束，表示此次资源分配会发生死锁
if(!b){
System.out.println("发生死锁");
return false;
}
}

System.out.println("资源分配成功");
return true;//表示此次资源分配不会发生死锁
}
}

}