c++ 模拟银行家调度算法 避免进程死锁

模拟银行家调度算法 避免进程死锁

题目要求

3.2**、银行家算法**

设Requesti是进程Pi的请求向量，如果Requesti［j］=K，表示进程Pi需要K个Rj类型的资源。当Pi发出资源请求后，系统按下述步骤进行检查：

(1)如果Requesti［j］≤Need［i,j］，便转向步骤(2)；否则认为出错，因为它所需要的资源数已超过它所宣布最大值。

(2)如果Requesti［j］≤Available［j］，便转向步骤(3)；否则，表示尚无足够资源，Pi须等待。

(3)系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：

Available［j］=Available［j］-Requesti［j］;

Allocation［i,j］=Allocation［i,j］+Requesti［j］;

Need［i,j］=Need［i,j］-Requesti［j］;

系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。若安全，才正式将资源分配给进程Pi，以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。

3.3**、安全性算法**

1）设置两个向量：

工作向量Work: 它表示系统可提供给进程继续运行所需的各类资源数目，它含有m个元素，在执行安全算法开始时，Work=Available;

工作向量Finish: 它表示系统是否有足够的资源分配给进程，使之运行完成。开始时先做Finish［i］=false; 当有足够资源分配给进程时， 再令Finish［i］=true。

2）从进程集合中找到一个能满足下述条件的进程： 

Finish［i］=false;

Need［i,j］≤Work［j］；若找到，执行 (3)，否则，执行 (4)

3）当进程Pi获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：

Work［j］=Work［i］+Allocation［i,j］;

Finish［i］=true;

go to step 2;

4）如果所有进程的Finish［i］=true都满足，则表示系统处于安全状态；否则，系统处于不安全状态

---

算法流程图

撸代码实现：

只要对银行家算法有印象，对着题目要求写一遍就好了，算是一道模拟题。

我踩得坑在安全性算法这块，在检测一个进程的分配资源大于work矩阵后，就不能再继续检测了，因为一个进程需要所有需求资源才能变状态为true，所以需要在里面加一个break，跳过开始检测下一个进程，见注释。

此外这个是试探性分配资源，也就是失败了需要吧状态恢复，在算法里也叫回溯。

代码：

#include <stdio.h>
#include <iostream>
using namespace std;

int main(){
    int available [10];
    int maxn [10][10];
    int allocation [10][10];
    int need [10][10];
    int n,m;
    cout<<"输入进程数量n，和资源数量m";
    cin>>n>>m; 
    cout<<"available: "; 
    for(int i = 0 ;i<m;i++){
        scanf("%d",&available [i]);     //各资源可用数量       
    }
    for(int i = 0 ;i<n;i++){

        for(int j = 0;j<m;j++){
            cout<<"\n输入P"<<i+1<<"对"<<j+1<<"的最大需求和已分配资源：\n";
            scanf("%d%d",&maxn [i][j],&allocation [i][j]);

            need [i][j] = maxn[i][j] - allocation[i][j];

        }
    }   



    //请求,进程1对第三种资源请求 1 
    int request[n][m];
    request[0][2] = 1;
    cout<<"请求,进程1对第三种资源请求 1"<<endl;

    if(request[0][2] > need[0][2]){
        cout<<"请求大于需求"<<endl;
        return 0;
    }
    else if(request[0][2]>available[2]){
        cout<<"请求小于可用资源";
        return 0;
    }
    else {
                              //此处试探分配，后面要回溯 
        available [2] = available [2] - request [0][2];
        allocation [0][2] = allocation [0][2] +request[0][2];
        need [0][2] = need[0][2] - request[0][2]; 
    }
    cout<<"试探分配后的需求矩阵：\n"; 
    for(int i =0 ;i<n;i++){
        cout<<"P"<<i+1;
        for (int j =0 ;j<m;j++){
            printf(" %d ",need[i][j]);
        }
        cout<<endl;
    }
    //安全性算法

    int work [10];
    bool finish[10]={false};
    cout<<"work矩阵： " ;
    for(int i =0 ;i<m;i++){
        work[i] = available[i];
        cout<<work[i]<<" ";
    } 
    cout<<endl;

    step:
        for(int i =0;i<n;i++){
            if(!finish[i]){
                int j =0;
                for(j =0;j<m;j++){
                //  printf("p1 need  %d  word %d\n",need[i][j],work[j]);
                    if(need[i][j]<=work[j]){
                        continue;   //j资源符合，判断下一种 
                    }
                    break;        //只要有一种资源申请失败，则跳出，寻找下一个进程。 
                }
                if(j==m){               //全部资源符合 出来的话j=m 
                    for(j = 0;j<m;j++)
                        work[j] = work [j] + allocation[i][j];  //这时候就能释放i的资源 
                    finish[i] = true;
                    goto step; 
                }
            }
        }

    int flag = 0;
    for (int i =0;i<n;i++){

        if(!finish[i]){
            flag = 1;
            break;
        }
    }
    if(flag){
        cout<<"不安全状态"<<endl;
        //回溯
        available [2] = available [2] + request [0][2];
        allocation [0][2] = allocation [0][2] - request[0][2];
        need [0][2] = need[0][2] + request[0][2]; 
    }
    else {
        cout<<"安全状态，进程全部运行"<<endl;
    }


}