C++实现操作系统银行家算法的模拟实现

该实验具体要求为：

（1）设计3-4个并发进程，共享系统的10个同类不可抢占的资源。各进程动态地进行资源的申请和释放。
（2）用银行家算法设计一个资源分配程序，运行这两个程序，观察系统运行情况，并对系统运行的每一步情况进行显示。

具体做法：

1.首先建立一个数组类，包含四个元素（即代表四个进程），在类中定义四个私有变量need,maxrequire,already,flag分别代表进程的资源仍需申请量，资源需求总量，已占资源量 和 能否执行完标志（其实设置为公有变量比较省事，因为可以直接访问修改它的值，不需要在类中额外设计函数，但因为本实验可以说有两周的时间，相当充分，理应考虑到编码规范，使用私有变量更符合设计规范），然后再设计一些函数来查看，修改这四个变量的值。
2.建立一个display1()函数，其作用是查看当前状态各个进程的资源占有，仍需情况等，因为本实验要求对系统运行的每一步情况进行显示，因此此函数将被频繁调用；建立banker()函数，其功能为通过循环查找，为满足条件的进行分配资源，查看是否存在安全序列，有则输出，无则返回提示；建立safety()函数，其作用是在银行家算法执行完以后，将各资源返回初始状态，去执行用户的为某个特定进程分配指定的资源后，判断系统是否进入不安全状态（本质是调用banker()函数查看是否仍然存在安全序列）。

实验完整代码：

#include
#include
#include
#include
#include 
using namespace std;
int available = 10;
class PCB
{
     
public:
    PCB()
    {
     
        need = 0;
        maxrequire = 0;
        already = 0;
        flag = false;
    }
    void setflag()
    {
     
        flag = true;
    }
    void setmax(int a)
    {
     
        maxrequire = a;
    }
    void application(int a)
    {
     
        if(available<a)
            cout<<"资源不足，分配资源失败！"<<endl;
        else
        {
     
            available = available - a;
            already = already + a;
            need = maxrequire - already;
            cout<<"资源分配成功！"<<endl;
        }
    }
    void display()
    {
     
        cout<<maxrequire<<"\t"<<already<<"\t"<<need<<"\n"<<endl;
    }
    int getmax(){
     return maxrequire;}
    int getneed(){
     return need;}
    int getalready(){
     return already;}
    bool getflag(){
     return flag;}
private:
    int need;           //资源仍需申请量
    int maxrequire;     //资源需求总量
    int already;        //已占资源量
    bool flag;          //能执行完标志
};

void display1(PCB *p)//显示进程当前状态函数
{
     
    cout<<"目前各进程资源情况如下："<<endl;
    cout<<"\t总需\t已占\t仍需"<<endl;
    cout<<"A\t";
    p[0].display();
    cout<<"B\t";
    p[1].display();
    cout<<"C\t";
    p[2].display();
    cout<<"D\t";
    p[3].display();

}

void banker(PCB *p)//银行家算法
{
     
    cout<<"\n现在用银行家算法去处理这四个进程：\n"<<endl;
    int time=0;
    int gy = 0;
    int x[4]={
     0,0,0,0};

    while(1)
    {
     
        if(time==4)
            break;

        for(int i=0;i<4;i++)
        {
     
            if(p[i].getflag() == false)
            {
     
                if(p[i].getneed()<=available)
                {
     
                    p[i].application(p[i].getneed());
                    available = available + p[i].getalready();
                    p[i].setflag();
                    x[gy]=i;    //用数组记录进程执行顺序
                    gy++;
                    display1(p);
                }
            }
        }
        time++;
    }
    if(p[0].getflag()==true && p[1].getflag()==true && p[3].getflag()==true&& p[4].getflag()==true)
    {
     
        cout<<"\n找到一条安全序列如下："<<endl;
        if(x[0]==0)
            cout<<"A";
        else if(x[0]==1)
            cout<<"B";
        else if(x[0]==2)
            cout<<"C";
        else
            cout<<"D";

        for(int i=1;i<4;i++)
        {
     
            if(x[i]==0)
                cout<<"-->A";
            else if(x[i]==1)
                cout<<"-->B";
            else if(x[i]==2)
                cout<<"-->C";
            else
                cout<<"-->D";
        }
    }
    else
        cout<<"\n产生死锁，未找到安全序列！\n"<<endl;
    cout<<endl;

}

void safety(PCB *p) //安全性检查算法
{
     
    int i;
    int n;
    cout<<"请输入为哪个进程分配资源：(注意要输入数字，0-3分别代表进程A-D)"<<endl;
    cin>>i;
    cout<<"请输入要为该进程分配多少资源:"<<endl;
    cin>>n;
    if(n>available)
        cout<<"预分配的资源数，大于总资源可用数，分配失败！"<<endl;
    else
    {
     
        p[i].application(n);
display1(p);
        banker(p);      //使用银行家算法去处理判断是否可以分配
        if(p[0].getflag()==true && p[1].getflag()==true && p[3].getflag()==true&& p[4].getflag()==true)
            cout<<"已经找到安全序列，说明系统安全，可以为其先分配资源！"<<endl;
        else
            cout<<"未找到安全序列，说明系统进入不安全状态，因此不可以为其先分配资源！"<<endl;
    }

}



int main()
{
     
    cout<<"\nB51714023 郭云"<<endl;
    cout<<"**********银行家算法**********\n"<<endl;
    cout<<"开始时，系统可用资源为10个"<<endl;
    PCB p[4];
    int x1,x2,x3,x4;
    int y1,y2,y3,y4;
    printf("请输入A进程的所需资源总量和已占有量：");
    scanf("%d %d",&x1,&y1);
    printf("请输入B进程的所需资源总量和已占有量：");
    scanf("%d %d",&x2,&y2);
    printf("请输入C进程的所需资源总量和已占有量：");
    scanf("%d %d",&x3,&y3);
    printf("请输入D进程的所需资源总量和已占有量：");
    scanf("%d %d",&x4,&y4);
    p[0].setmax(x1);
    p[1].setmax(x2);
    p[2].setmax(x3);
    p[3].setmax(x4);
    p[0].application(y1);
    p[1].application(y2);
    p[2].application(y3);
    p[3].application(y4);
    cout<<"此时，系统可用资源为"<<available<<"个"<<endl;
    display1(p);
    banker(p);

    cout<<"\n**********安全性检查**********"<<endl;
    cout<<"下面进行安全性检查，所有进程的占用资源量回到初始数据，具体如下：\n"<<endl;
    available = 10; //数据恢复初始值，开始安全性检查
    cout<<"此时，系统可用资源为"<<available<<"个"<<endl;
    PCB q[4];
    q[0].setmax(x1);
    q[1].setmax(x2);
    q[2].setmax(x3);
    q[3].setmax(x4);
    q[0].application(y1);
    q[1].application(y2);
    q[2].application(y3);
    q[3].application(y4);
    cout<<"此时，系统可用资源为"<<available<<"个"<<endl;
    display1(q);
    safety(q);

    cout<<"\n系统完全运行完毕，欢迎再次使用，再见"<<endl;
    return 0;
}

运行结果与分析：

实验运行结果截图如下：
首先，由用户自己定义各进程的所需资源总量以及已经占有量：

此时，各进程已经占有的资源已经自动分配成功，开始用银行家算法查找安全序列：

可以看出，资源已经分配成功，在最后也成功的输出了安全序列，接下来进行安全性检查，由用户手动输入为某个特定进程分配资源：

可见，用户要求为D进程分配的资源已经拟分配，现在用银行家算法查找是否仍然存在安全序列：


可见，仍然存在一条安全序列，可以为其先分配资源，系统运行完毕，成功结束。