操作系统之银行家算法

简介

银行家算法是避免死锁的一种重要方法，本程序用java编程语言对其进行了实现。
源代码移步：http://download.csdn.net/download/chengshijian2015/10215467

银行家算法原理

当用户申请一组资源时，系统必须做出判断，如果把这些资源分出去，系统是否还处于安全状态。
若是，就可以分出这些资源；否则，该申请暂不予满足。
1．数据结构
假设有M个进程N类资源，则有如下数据结构：
MAX[M*N] M个进程对N类资源的最大需求量
AVAILABLE[N] 系统可用资源数
ALLOCATION[M*N] M个进程已经得到N类资源的资源量
NEED[M*N] M个进程还需要N类资源的资源量
2．银行家算法
设进程I提出请求Request[N]，则银行家算法按如下规则进行判断。
(1)如果Request[N]<=NEED[I，N]，则转(2)；否则，出错。
(2)如果Request[N]<=AVAILABLE，则转(3)；否则，出错。
(3)系统试探分配资源，修改相关数据：
AVAILABLE=AVAILABLE-REQUEST
ALLOCATION=ALLOCATION+REQUEST
NEED=NEED-REQUEST
(4)系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。
3．安全性检查
(1)设置两个工作向量WORK=AVAILABLE；FINISH[M]=FALSE
(2)从进程集合中找到一个满足下述条件的进程，
FINISH[i]=FALSE
NEED<=WORK
如找到，执行(3)；否则，执行(4)
(3)设进程获得资源，可顺利执行，直至完成，从而释放资源。
WORK=WORK+ALLOCATION
FINISH=TRUE
GO TO 2
(4)如所有的进程Finish[M]=true，则表示安全；否则系统不安全。

java源码

BankerAlgorithm.java:

package bankersalgorithm;

import java.util.Scanner;

public class BankerAlgorithm {

    // 银行家算法

    /**
     * 
     * 4个线程，3个资源
     * 
     * @param args
     */
    public static void main(String[] args) {

        // 1．设计进程对各类资源最大申请表示及初值确定。
        // 2．设定系统提供资源初始状况。
        // 3．设定每次某个进程对各类资源的申请表示。
        // 4．编制程序，依据银行家算法，决定其申请是否得到满足。

        new BankerAlgorithmPresenter().execute(new OnExcuteListener() {

            @Override
            public int onStartInputData() {
                Scanner scanner = new Scanner(System.in);
                System.out.print("请输入进程序号（0-3）>");
                return scanner.nextInt();
            }

            @Override
            public void onError() {
                // TODO Auto-generated method stub
                System.out.println("请求资源数大于需要的资源数，出错！");
            }

            @Override
            public void onSuccess(boolean isSafeState) {
                // TODO Auto-generated method stub
                if (isSafeState) {
                    System.out.println("系统处于安全状态！");
                } else {
                    System.out.println("系统处于不安全状态！");
                }
            }

            @Override
            public void onWait(int threadId) {
                // TODO Auto-generated method stub
                System.out.println("进程" + threadId + "等待...");
            }
        });
    }
}

BankerAlgorithmPresenter.java:

package bankersalgorithm;

public class BankerAlgorithmPresenter {
    private boolean isError = false;// 是否出错
    private boolean isWait = false;// 是否处于等待状态
    private boolean isSafeState = true;// 是否安全状态
    private int threadId;// 进程序号
    private boolean isNeedLargerThanWork = false;//资源需求量是否大于work数量
    private Data data;
    private int [][]REQUEST;
    private int []AVAILABLE;
    private int [][]NEED;
    private int [][]MAX;
    private int[][]ALLOCATION;

    boolean[] isFinished = { false, false, false, false };// 为4个进程初始化完成情况为false

    public BankerAlgorithmPresenter() {
        super();
        // TODO Auto-generated constructor stub
        data=new Data();
        REQUEST=data.getREQUEST();
        AVAILABLE=data.getAVAILABLE();
        NEED=data.getNEED();
        MAX=data.getMAX();
        ALLOCATION=data.getALLOCATION();
    }

    public void setThreadId(int threadId) {
        this.threadId=threadId;
    }

    //检查是否出错
    private void checkIsError() {
        for (int i = 0; i < 3; i++) {
            if (REQUEST[threadId][i] > NEED[threadId][i]) {
                isError = true;
                break;
            }
        }
    }

    //检查是否出错
    private void checkIsWait() {
        for (int i = 0; i < 3; i++) {
            if (REQUEST[threadId][i] > AVAILABLE[i]) {
                isWait = true;
                break;
            }
        }
    }

    //安全性算法中更新数据结构
    private void update(int i,int WORK[]) {
        if (!isNeedLargerThanWork) {
            isFinished[i] = true;
            for (int k = 0; k < 3; k++) {
                WORK[k] += ALLOCATION[i][k];
            }
        } else {
            isNeedLargerThanWork = false;
        }
    }

    //安全性算法中查找满足条件的值
    private void serach(int i,int []WORK) {
        if (!isFinished[i]) {
            for (int j = 0; j < 3; j++) {// 资源数
                if (NEED[i][j] > WORK[j]) {
                    isNeedLargerThanWork = true;
                    break;
                }
            }
        }
    }

    //查找是否有isFinished=falsed的情况发生
    private void checkIsFinished() {
        for (int i = 0; i < 4; i++) {
            if (!isFinished[i]) {
                isSafeState = false;
                break;
            }
        }
    }

    //安全性算法
    private void safe() {
        // 系统执行安全性算法
        int[] WORK = AVAILABLE;
        // 开始查找满足条件的进程资源分配情况
        // 并改变数据结构中的值
        for (int i = 0; i < 4; i++) {// 进程数
            serach(i, WORK);
            update(i, WORK);
        }
    }

    //执行安全性算法
    private void excuteSafeAlgorithm() {
        safe();
        checkIsFinished();
    }

    //更改数据结构
    private void allocate() {
        for (int i = 0; i < 3; i++) {
            AVAILABLE[i] -= REQUEST[threadId][i];
            ALLOCATION[threadId][i] += REQUEST[threadId][i];
            NEED[threadId][i] -= REQUEST[threadId][i];
        }
    }

    //执行
    public void execute(OnExcuteListener listener) {
        threadId=listener.onStartInputData();
        checkIsError();
        if (!isError) {
            checkIsWait();
            if (!isWait) {
                allocate();
                excuteSafeAlgorithm();
                listener.onSuccess(isSafeState);
            } else {
                listener.onWait(threadId);
            }
        } else {
            listener.onError();
        }
    }
}

Data.java:

package bankersalgorithm;

public class Data {

    int[][] MAX = { 
            { 3, 2, 2 },
            { 6, 1, 3 }, 
            { 3, 1, 4 }, 
            { 4, 2, 2 }
        };// M个进程对N类资源的最大需求量

    int[] AVAILABLE = { 2, 1, 2 };// 系统可用资源数

    int[][] ALLOCATION = { 
            { 1, 0, 0 }, 
            { 2, 1, 1 }, 
            { 2, 1, 1 }, 
            { 0, 0, 2 } 
        };// M个进程已经得到N类资源的资源量

    int[][] NEED = { 
            { 2, 1, 1 },
            { 3, 1, 2 },
            { 1, 0, 3 }, 
            { 4, 2, 0 } 
        };// M个进程还需要N类资源的资源量

    int[][] REQUEST = {
            { 1, 0, 1 }, 
            { 3, 0, 1 },
            { 3, 1, 1 }, 
            { 1, 0, 0 } 
        };// M个进程还需要N类资源的资源量

    public int[][] getMAX() {
        return MAX;
    }

    public void setMAX(int[][] mAX) {
        MAX = mAX;
    }

    public int[] getAVAILABLE() {
        return AVAILABLE;
    }

    public void setAVAILABLE(int[] aVAILABLE) {
        AVAILABLE = aVAILABLE;
    }

    public int[][] getALLOCATION() {
        return ALLOCATION;
    }

    public void setALLOCATION(int[][] aLLOCATION) {
        ALLOCATION = aLLOCATION;
    }

    public int[][] getNEED() {
        return NEED;
    }

    public void setNEED(int[][] nEED) {
        NEED = nEED;
    }

    public int[][] getREQUEST() {
        return REQUEST;
    }

    public void setREQUEST(int[][] rEQUEST) {
        REQUEST = rEQUEST;
    }
}

OnExcuteListener.java:

package bankersalgorithm;

public interface OnExcuteListener {
    int onStartInputData();
    void onError();
    void onSuccess(boolean isSafeState);
    void onWait(int threadId);
}