操作系统死锁避免——银行家算法

任务

编写和调试一个简单的银行家算法程序：

1. 设定进程对各类资源最大的申请数量；
2. 设定系统提供资源的初始数量；
3. 设定每次某个进程对各类资源的申请数量；
4. 编写程序，依据银行家算法，决定其资源申请是否得到满足；
5. 显示资源申请和分配时的变化情况。

要求

1. 调用input()函数，输入进程总数，资源种类数， Max矩阵，Allocation矩阵以及Available向量；
2. 调用print()函数输出已知条件；
3. 调用check()函数检测T0时刻的安全状态；
   （1）不安全则结束；
   （2）安全则输入请求资源的进程号和所请求的资源数。
4. 判断请求是否满足条件：
   （1）若满足则尝试分配资源给进程，并调用print()函数输出尝试后的情况，调用check()函数判断分配后是否安全；
   （a）若安全则按照该方案分配资源给进程，并输出分配后的情况，结束此次分配，并判断是否继续分配，是的话则执行3（2），不继续分配则结束；
   （b）不安全则还原已分配资源数，并调用print()函数输出分配前的情况，并判断是否继续分配，是的话则执行3（2），不继续分配则结束。
   （2）若不满足则判断是否继续分配，是的话则执行3（2），不继续分配则结束。

代码

cpp

#include <bits/stdc++.h>
using namespace std;
int processNum,ziYuanNum;
vector<vector<int>> Max,Allocation;
vector<int> Available,st,safe_List;
int yf[10];
void input(vector<vector<int>> &a)
{
    int i,j;
    for(i=0;i<processNum;i++)
    {
        for(j=0;j<ziYuanNum;j++)
        {
            cin>>a[i][j];
        }
    }
}

bool check()
{
    safe_List.clear();
    vector<int> Copy_Available=Available;
    st=vector<int>(processNum);
    for(int i=0;i<processNum;i++)
    {
        for(int j=0;j<processNum;j++)
        {
            if(st[j])continue;
            int f=1;

            for(int w=0;w<ziYuanNum&&yf[j]==0;w++)
            {
                if(Copy_Available[w]<Max[j][w]-Allocation[j][w])
                {
                    f=0;
                    break;
                }
            }
            if(f)
            {
                for(int w=0;w<ziYuanNum;w++)
                {
                    Copy_Available[w]+=Allocation[j][w];
                }
                safe_List.push_back(j);
                st[j]=1;
            }
        }
    }
    if(safe_List.size()==processNum)
    {
        return true;
    }

    return false;

}
void print()
{
    cout<<"------------------------------此时刻资源分配情况------------------------------\n"
          "|    进程名    |     Max     |   Allocation   |    Need    |    Available    |\n";
    for(int i=0;i<processNum;i++)
    {
        cout<<"\tp"<<i<<"\t";
        for(int j=0;j<ziYuanNum;j++)
        {
            cout<<Max[i][j]<<" ";
        }
        cout<<"\t\t";
        for(int j=0;j<ziYuanNum;j++)
        {
            cout<<Allocation[i][j]<<"  ";
        }
        cout<<"\t";
        for(int j=0;j<ziYuanNum;j++)
        {
            if(yf[i])cout<<"0  ";
            else cout<<Max[i][j]-Allocation[i][j]<<"  ";
        }
        if(i==0)
        {
            cout<<"\t";
            for(int j=0;j<ziYuanNum;j++)
            {
                cout<<Available[j]<<"  ";
            }

        }
        cout<<"\n";
    }
    cout<<"------------------------------------------------------------------------------\n";

}
bool  fen(int pid)
{
    int f=1;
    for(int i=0;i<ziYuanNum;i++)
    {
        if(Max[pid][i]-Allocation[pid][i]>Available[i])
        {
            f=0;
            break;
        }
    }
    if(f)
    {
        for(int i=0;i<ziYuanNum;i++)
        {
            Available[i]+=Allocation[pid][i];
            Allocation[pid][0]=0;
        }
        yf[pid]=1;
        return true;
    }
    throw exception();
}
int main() {
    cout<<"******************************************************\n"
          "*               银行家算法的设计与实现               *\n"
          "******************************************************\n";
    cout<<"请输入进程总数: ";
    cin>>processNum;
    cout<<"请输入资源种类数: ";
    cin>>ziYuanNum;
    Available=vector<int>(ziYuanNum);
    Max=vector<vector<int>>(processNum,vector<int>(ziYuanNum));
    Allocation=vector<vector<int>>(processNum,vector<int>(ziYuanNum));

    cout<<"请输入Max矩阵:\n";
    input(Max);
    cout<<"请输入Allocation矩阵:\n";
    input(Allocation);
    cout<<"请输入可用资源数Available[i]:";
    for(int i=0;i<ziYuanNum;i++)
    {
        cin>>Available[i];
    }

    print();
    if(check())
    {
        cout<<"系统当前为安全状态,安全序列为: { ";
        for(int i=0;i<processNum;i++)
        {
            if(i!=0)cout<<", ";
            cout<<"p"<<safe_List[i];
        }
        cout<<" }\n";
    }else
    {
        cout<<"系统处在不安全状态!";
        return 0;
    }
    while(1)
    {
        cout<<"请输入请求资源的进程号(0"<<"~"<<processNum-1<<"): ";
        int pid;
        cin>>pid;
        if(pid<processNum)
        {
            cout<<"请输入该进程所请求的资源数request[j]:";
            vector<int> req(ziYuanNum);
            int f=1;
            for(int i=0;i<ziYuanNum;i++)
            {
                cin>>req[i];
                if(req[i]>Available[i])
                {
                    f=0;
                }
            }
            if(f==0)
            {
                cout<<"没有足够的资源分配,请求失败!\n";
                continue;
            }

            try {
                cout<<"尝试分配后的有关资源数据\n";
                fen(pid);
                print();
                if(check())
                {
                    cout<<"系统当前为安全状态,安全序列为: { ";
                    for(int i=0;i<processNum;i++)
                    {
                        if(i!=0)cout<<", ";
                        cout<<"p"<<safe_List[i];
                    }
                    cout<<" }\n";
                }
            }catch (...){
                cout<<"系统处在不安全状态!返回分配前资源数\n";
            }
        }else
        {
            continue;
        }
        print();
        char c;
        cout<<"是否还需要继续分配? (Y or N ?)\n";
        cin>>c;
        if(c=='Y') {
            continue;
        }else
        {
            break;
        }

    }

    return 0;
}
/*
5
3
7 5 3
3 2 2
9 0 2
2 2 2
4 3 3
0 1 0
2 0 0
3 0 2
2 1 1
0 0 2
3 3 2
 */