银行家算法
简介
银行家算法（Banker’s Algorithm）是一个避免死锁（Deadlock）的著名算法
如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。安全状态一定是没有死锁发生。
数据结构：
available[j]=k: 系统现有Rj类资源k个；
max[i,j]=k: 进程i需要Rj的最大数k个；
alloc[i,j]=k: 进程i已得到Rj类资源k个；
need[i,j]=k: 进程i需要Rj类资源k个
有：need[i,j]= max[i,j]－alloc[i,j]
requesti 进程i请求资源数
worki：进程i执行完后系统应有资源数（也即可用数）
finish[i]：布尔量，表进程i能否顺序完成。
银行家算法
设Requesti是进程Pi的请求向量，如果进程Pi需要K个Rj类资源，当Pi发出资源请求后，系统按下述步骤进行检查：
1 如果Requesti≤Needi,则转向步骤2；否则认为出错。（因为它所需要的资源数已超过它所宣布的最大值。
2 如果Requesti≤Available,则转向步骤3；否则，表示系统中尚无足够的资源，Pi必须等待
3 系统试探把要求的资源分配给进程Pi，并修改下面数据结构中的数值：
Available:=Available-Requesti;
Allocation:=Allocation+Requesti;
Needi:= Needi- Requesti;
4 系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。若安全，正式将资源分配给进程Pi，以完成本次分配；否则，将试探分配作废，恢复原来的资源分配状态，让进程Pi等待。
安全性算法
系统所执行的安全性算法可描述如下：
1 设置两个向量
①工作向量Work.它表示系统可提供给进程继续运行所需要的各类资源的数目，它含有m个元素，执行安全算法开始时，Work:=Available。
②Finish.它表示系统是否有足够的资源分配给进程，使之运行完成。开始时先做Finish[i]:=false；当有足够的资源分配给进程时，令Finish[i]:=true.
2 从进程集合中找到一个能满足下述条件的进程：①Finish[i]=false; ②Needi≤Work. 如找到，执行步骤3；否则执行步骤4。
3 当进程Pi获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故执行：
Work:=Work+Allocation;
Finish[i]:=true;
Goto step2;
4 如果所有进程的Finish[i]=true，则表示系统处于安全状态；否则，系统处于不安全状态。
（1）验证此时的安全性
（2）p1请求资源（1，0，2）
（3）p4请求资源（3，3，0）
（4）p0请求资源（0，2，0）
Java代码：
//banker.java
import java.util.ArrayList;
public class banker {
ArrayList proArry=new ArrayList();
//process [] proArry=new process[5];
available _available=new available();
Max b=new Max();
allocation _allocation=new allocation();
need _need=new need();
//new star();
void addProcess(process p){
//proArry[proArry.length]=p;
proArry.add(p);
//finish[proArry.size()]=false;
}
boolean ruquest(process p){
for(int i=0;i<p.request.length;i++){
if(p.request[i]>this._need.a[p.getNum()][i]){
return false;
}
}
for(int i=0;i<p.request.length;i++){
//System.out.println("--------"+p.request[i]+this._available.a[i]);
if(p.request[i]>this._available.a[i]){
return false;
}
}
return true;
}
boolean distribution(process p){
if(this.ruquest(p)){
for(int i=0;i<p.request.length;i++){
this._available.a[i]=this._available.a[i]-p.request[i];
this._allocation.a[p.getNum()][i]=this._allocation.a[p.getNum()][i]+p.request[i];
this._need.a[p.getNum()][i]=this._need.a[p.getNum()][i]-p.request[i];
//System.out.println("--haha---"+p.request[i]+this._available.a[i]);
}
return true;
}else
return false;
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
process p0=new process(0);
process p1=new process(1);
process p2=new process(2);
process p3=new process(3);
process p4=new process(4);
banker bank=new banker();
int []a={1,0,2};
int []b={3,3,0};
int []c={0,2,0};
bank.addProcess(p0);
bank.addProcess(p1);
bank.addProcess(p2);
bank.addProcess(p3);
bank.addProcess(p4);
safe safety=new safe(bank);
safety.text();
p1.setRequest(a);
if(bank.distribution(p1)){
safety.text();
}else
System.out.println("资源不足，请等待");
p4.setRequest(b);
if(bank.distribution(p4)){
safety.text();
}else
System.out.println("资源不足，请等待");
p0.setRequest(c);
if(bank.distribution(p0)){
safety.text();
}else
System.out.println("资源不足，请等待");
}
}
//safe.java
import java.util.ArrayList;
class available{
int []a;
available(){
int []b={3,3,2};
a=b;
}
}
class Max{
int [][]a;
Max(){
int [][]b={
{7,5,3},
{3,2,2},
{9,0,2},
{2,2,2},
{4,3,3}
};
a=b;
}
}
class allocation{
int [][]a;
allocation(){
int [][]b={
{0,1,0},
{2,0,0},
{3,0,2},
{2,1,1},
{0,0,2}
};
a=b;
}
}
class need{
int [][]a;
need(){
int [][]b={
{7,4,3},
{1,2,2},
{6,0,0},
{0,1,1},
{4,3,1}
};
a=b;
}
}
class process{
int []request=new int[3];
int num;
//boolean state;
process(int a){
// request=b;
num=a;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public int[] getRequest() {
return request;
}
public void setRequest(int[] request) {
this.request = request;
}
// void setState(boolean a){
// state=a;
// }
// boolean getState(){
// return state;
// }
}
//class input{
//
// input(banker b){
// for(int i=0;i<this.work.a.length;i++){
// System.out.print(b.work.a[i]+" ");
// }
// System.out.println("");
// System.out.println("---------------------------");
// }
//}
class safe {
/**
* @param args
*/
banker _b;
int [] work=new int[100];
boolean []finish=new boolean[20];
safe(banker b){
_b=b;
this.text();
}
void initFinish(boolean[]b){
for(int i=0;i<b.length;i++){
b[i]=false;
}
}
boolean compare(int dex){
for(int i=0;i<_b._need.a[dex].length;i++){
if(_b._need.a[dex][i]>this.work[i]){
return false;
}
}
return true;
}
public void set_b(banker _b) {
this._b = _b;
}
void text(){
System.arraycopy(this._b._available.a, 0, this.work, 0, this._b._available.a.length);
initFinish(finish);
// for(int i=0;i<3;i++){
// //System.out.println("work"+work[i]);
// }
for(int i=0;i<_b.proArry.size();i++){
//System.out.println("--"+i);
//System.out.println("----"+this.compare(i));
if(this.finish[i]==false&&this.compare(i)){
for(int j=0;j<_b._allocation.a[i].length;j++){
this.work[j]=this.work[j]+_b._allocation.a[i][j];
}
//System.out.println("P_"+i+"进程");
//new input(this);
this.finish[i]=true;
i=-1;
continue;
}
}
for(int i=0;i<_b.proArry.size();i++){
if(this.finish[i]==false){
//return false;
System.out.println("不安全");
return;
}
}
//return true;
System.out.println("安全");
return;
}
}
