模拟银行家算法实验-----一不小心暴露自己是河北工业大学的

                                                                                                   操作系统----模拟银行家算法

        简介：2015级，大三狗，菜，人傻，哈哈，不过喜欢编程啦。贴个实验时做的算法，挺有意思。 如有需求，请做参考，什么换换参数名字呀，函数名字呀，调换代码位置呀，切换 输出的格式呀。。。知道期末很忙，但不要照着抄啦，等会儿都挂了就爽歪歪，哈哈哈，就这样。

以下是代码主要内容。。。与注释，被自己的贴心与善良感动。 本人脸皮厚，深知其菜。欢迎吐槽！

        #include"stdio.h"

#include"stdlib.h"

#include"string.h"

#include<iostream>

#include<cstring>

#include<vector>

#include<iomanip>

using namespace std;

//Available[i] 系统中现有的i类资源数

//Max[1:n,1:m] i进程对j 类资源的最大需求量

//Allocation[i,j] 进程i 已占有的j类资源的数量

//Need[i,j] 表示进程i还需要申请的j类资源的数量

//Need[i,j]=Max[i,j]-Allocation[i,j]

//Request[i,j]=k,进程i申请k个j类资源

//步骤1：如果Request[i,j]+Allocation[i,j]<Max[i,j],是:转向步骤2..否，需求量太大，报错

//步骤2：如果Request[i,j]<=Avaliable[j]成立，转向步骤3，如果不成立，阻塞

//步骤3：系统试探着把资源分配给进程P[i], 并修改下面数据结构当中的值：

//Available[i,j]=Available[j]-Request[i,j]

//Allocation[i,j]=Allocation[i,j]+Request[i,j]

//Need[i,j]=Need[i,j]-Request[i,j]

//步骤4：调用系统安全性检查算法，检查此次资源分配后系统是否处于安全状态。若安全，满足进程Pi的资源申请

//否则，将本次试探分配作废，恢复原来的资源分配状态。

//安全状态检查算法

//步骤1：初始化

// 工作向量： work[i:m]: 他表示系统可提供给进程继续运行所需的各类资源数目，它含有m个元素

//表示系统中的资源类型数。在执行安全算法开始时，Work=Available;

//bool 类型向量 Finish[1:n] 他表示是否有足够的资源分配给各个进程，使之运行完成。开始时令

//Finish[i]=false;当有足够资源非配给进程Pi时，置 Finish[i]=true;

//步骤2：

//寻找一个进程，Finish[i]=false 且Need[i,j]<=Work[j]，找到执行步骤3，找不到执行步骤4

//步骤3：释放资源，进程得以完成：Work[j]=Work[j]+Allocation[i,j],Finish[i]=true,返回步骤2

//步骤4:Finish全为true，则为true,否则则是false,不安全

//时间复杂度 O(mxn^2)

int  n,m;

int &resource_num=n;

int &process_num=m;

const int MAX_PROCESS=50;

const int MAX_RESOURCE=50;

struct info

{

int P_MAX[MAX_RESOURCE];//声明所需要的最大的资源数

int allocation[MAX_RESOURCE];//进程已经获得资源数

int need[MAX_RESOURCE];  //进程还需获得资源数

}PROCESS[MAX_PROCESS];  //进程

int available[MAX_RESOURCE];//最大资源类型数为50个

int request[MAX_RESOURCE];  //试探分配的资源

void init()

{

    int i,j;

    printf("请输入资源种类数:");

    scanf("%d",&n);

        for(i=0;i<n;i++)

          {   printf("请输入第%d个资源的最大资源数:\n",i);

                scanf("%d",&available[i]);

            }

        printf("请输入进程数:");

    scanf("%d",&m);

    printf("请输入各进程对各资源的最大需求数:\n");

    for(i=0;i<m;i++)

          {  // printf("请输入第%d进程对各资源的最大需求数:\n",i);

              for(j=0;j<n;j++)

              {

                  cout<<"请输入第"<<i<<"个进程对"<<j<<"个资源的最大需求数:"<<endl;

                  scanf("%d",&PROCESS[i].P_MAX[j]);

                  PROCESS[i].allocation[j]=0;

                  PROCESS[i].need[j]=PROCESS[i].P_MAX[j];

              }

    }

          printf("\n");

}

int WORK[MAX_PROCESS];

int FINISH[MAX_PROCESS];

vector<int> ok_queue;

//进程数为 m，资源数为 n

int get_ok_process()

{

    int i,j,is_ok=1;

    for(i=0;i<process_num;i++)

    {

        if(FINISH[i]==false)

        {

        for(j=0;j<resource_num;j++)

        {

            if(PROCESS[i].need[j]>WORK[j])

            {

                is_ok=false;

            }

        }

        if(is_ok)

        {

          break;

        }else

        {

            is_ok=true;

        }

        }

    }

    return i;

}

int safe()

{

    ok_queue.clear();

    memset(FINISH,0,sizeof(FINISH));

    for(int i=0;i<resource_num;i++)

        WORK[i]=available[i];

    int i=get_ok_process();

    while(i<process_num)

    {

        for(int j=0;j<resource_num;j++)

        {

            WORK[j]+=PROCESS[i].allocation[j];

            FINISH[i]=true;

        }

         ok_queue.push_back(i);

        i=get_ok_process();

    }

    int is_safe=true;

    for(int haha=0;haha<process_num;haha++)

    {

       is_safe=is_safe&FINISH[haha];

    }

    return is_safe;

}

void print_Allocation(int times)

{

    cout.setf(ios::left);

    cout<<"-------------T"<<times<<"时刻"<<"资源分配图--------------"<<endl;

    cout<<setw(15)<<"-----PROCESS"<<

          setw(15)<<"--ALLOCATION"<<

          setw(15)<<"---------MAX"<<

          setw(15)<<"--------NEED"<<

          setw(15)<<"---AVAILABLE"<<endl;

    for(int i=0;i<process_num;i++)

    {

        cout<<"P"<<setw(15)<<i;

        for(int j=0;j<resource_num;j++)

        cout<<setw(5)<<PROCESS[i].allocation[j];

         for(int j=0;j<resource_num;j++)

        cout<<setw(5)<<PROCESS[i].P_MAX[j];

         for(int j=0;j<resource_num;j++)

        cout<<setw(5)<<PROCESS[i].need[j];

         for(int j=0;j<resource_num;j++)

        cout<<setw(5)<<available[j];

         cout<<endl;

    }

}

//ALLOCATION算法:

//Request[i,j]=k,进程i申请k个j类资源

//步骤1：如果Request[i,j]+Allocation[i,j]<Max[i,j],是:转向步骤2..否，需求量太大，报错

//步骤2：如果Request[i,j]<=Avaliable[j]成立，转向步骤3，如果不成立，阻塞

//步骤3：系统试探着把资源分配给进程P[i], 并修改下面数据结构当中的值：

//Available[j]=Available[j]-Request[j]

//Allocation[i,j]=Allocation[i,j]+Request[j]

//Need[i,j]=Need[i,j]-Request[j]

//步骤4：调用系统安全性检查算法，检查此次资源分配后系统是否处于安全状态。若安全，满足进程Pi的资源申请

//否则，将本次试探分配作废，恢复原来的资源分配状态。

void allo(int times)

{

   cout<<"第"<<times<<"次ALLOCATION:"<<endl;

   int i;

   cout<<"请输入您要分配的进程编号,上限为"<<process_num-1<<":"<<endl;

   cin>>i;

   if(i>=process_num||i<0)

   {

      cout<<"无此进程"<<endl;

      return ;

   }

       cout<<"请输入第"<<i<<"个进程"<<resource_num<<"个资源的ALLOCATION,用空格隔开:"<<endl;

       int is_ok=true;

       for(int j=0;j<resource_num;j++)

       {

           scanf("%d",&request[j]);

           if(request[j]>available[j]||

                   request[j]+PROCESS[i].allocation[j]

                   >PROCESS[i].P_MAX[j])

           {

               is_ok=false;

               break;

           }

       }

       if(is_ok)

       {

          for(int j=0;j<resource_num;j++)

          {

              available[j]=available[j]-request[j];

              PROCESS[i].allocation[j]+=request[j];

              PROCESS[i].need[j]-=request[j];

          }

          if(safe())

          {

             print_Allocation(times);

             cout<<"安全序列为:";

             for(int v=0;v<ok_queue.size();v++)

             {

                 cout<<ok_queue[v]<<" ";

             }

             cout<<endl;

          }

          else

          {

              cout<<"不安全，恢复原始分配状态"<<endl;

              for(int j=0;j<resource_num;j++)

              {

                  available[j]=available[j]+request[j];

                  PROCESS[i].allocation[j]-=request[j];

                  PROCESS[i].need[j]+=request[j];

              }

              print_Allocation(times);

          }

       }else

       {

           cout<<"需求量过大，无法满足，进程阻塞"<<endl;

       }

}

int main()

{

  int i;

  init();

  int times=0;

  do

  {

      printf("选择1--用银行家算法;选择0--退出:");

      scanf("%d",&i);

      if(i==1)

        allo(times++);

  }while(i==1);

  return 0;

}