银行家算法

简介

银行家算法（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;
    }

}