银行家算法实现（操作系统）附代码

实验目的
　　银行家算法（Banker’s Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。
　　在银行中，客户申请贷款的数量是有限的，每个客户在第一次申请贷款时要声明完成该项目所需的最大资金量，在满足所有贷款要求时，客户应及时归还。银行家在客户申请的贷款数量不超过自己拥有的最大值时，都应尽量满足客户的需要。在这样的描述中，银行家就好比操作系统，资金就是资源，客户就相当于要申请资源的进程。
　　银行家算法是一种最有代表性的避免死锁的算法。在避免死锁方法中允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。为实现银行家算法，系统必须设置若干数据结构。

实验内容
  Linux下实现银行家算法，通过构造可利用资源向量、最大需求矩阵、分配矩阵以及需求矩阵来进行判断，当进程请求资源时，系统必须确定是否有足够的资源分配给该进程，是否处于不安全状态。整个银行家算法分为假定分配资源、安全性检查两步，如果通过安全性检查，则为进程分配相应资源。
实验步骤、过程
一、数据结构
（1）可利用资源向量Available
  可利用资源向量是一个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目。如果Available［j］=K，则表示系统中现有Rj类资源K个。
（2）最大需求矩阵Max
  最大需求矩阵是一个n×m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。如果Max［i,j］=K，则表示进程i需要Rj类资源的最大数目为K。
（3）分配矩阵Allocation
  分配矩阵是一个n×m的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。如果Allocation［i,j］=K，则表示进程i当前已分得Rj类资源的数目为K。
（4）需求矩阵Need。
  需求矩阵是一个n×m的矩阵，用以表示每一个进程尚需的各类资源数。如果Need［i,j］=K，则表示进程i还需要Rj类资源K个，方能完成其任务。
  Need［i,j］=Max［i,j］-Allocation［i,j］
二、算法描述
1.银行家算法
  设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等待。

2.安全性算法
(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都满足， 则表示系统处于安全状态；否则，系统处于不安全状态;

运行结果
  假定系统中有五个进程{P0, P1, P2, P3, P4}和三类资源{A,B,C},各种资源的数量分别为10、5、7,在T0时刻的资源分配情况下表所示。
（1）T0时刻安全性检测
（2）P1请求资源: P1发出请求向量Request1(1, 0, 2)，系统按银行家算法进行检查，再利用安全性算法对分配后系统安全性进行检测判断是否真的分配。
（3）P4 请求资源: P4 发出请求向量Request4(3，3，0)。
（4）P0请求资源: P0发出请求向量Request0(0, 2, 0)。
（5）将（4）改为Request0(0, 1, 0)。

  经运行结果验证，此时刻通过了安全性算法得到检查，属于安全状态，不会发生死锁，接下来假设P1请求资源向量Request1为（1,0,2） 由所进行的安全性检查得知，可以找到一个安全序列{P1，P3，P0，P2，P4}。因此，系统是安全的，可以立即将P1所申请的资源分配给它。
请求资源（3,3,0）
满足Request（3,3,0）<=Need（4,3,1）
但是Request（3,3,0）>Avaliable（2,3,0），因此P4等待
下面P0请求资源（0,2,0）
由图可知，可用资源Available（2,1,0）已不能满足任何进程的需要，故系统没有通过安全性检查，进入不安全状态，此时系统不分配资源。

#include <iostream>
#include<cstring>
using namespace std;

#define False 0
#define True 1

//主要数据结构
int N=50;//进程的最大数
int M=100;//资源的最大数
char NAME[100]={0};//资源的名称
int Max[50][100]={0};//最大需求矩阵
int Avaliable[100]={0};//可用资源矩阵
int Allocation[50][100]={0};//系统已分配矩阵
int Need[50][100]={0};//还需要资源矩阵
int Request[100]={0};//请求资源向量
int Security[100]={0};//存放安全序列
int Work[100]={0};//存放系统可提供资源

/********
Initialization data: enter the number of processes and resource types
Available amount of various resources,
The allocated amount of resources for each process,
The maximum demand for resources in each process, etc.
********/
void chushihua()
{
/* n为进程个数，即矩阵行数，m为资源个数，即矩阵列数。*/

    int i,j,n,m;
    int number,flag;
    char name;//输入资源名称
    cout<<"The number of available resources in the system is:";
    cin>>m;
    M=m;
    for(i=0;i<m;i++)
    {
        cout<<"resources"<<i<<"name is";
        cin>>name;
        NAME[i]=name;
        cout<<"resources"<<name<<"the initial number is:";
        cin>>number;
        Avaliable[i]=number;
    }
    cout<<endl;
    cout<<"Please enter the number of processes:";
    cin>>n;
    N=n;
    cout<<"Please enter the value of the maximum demand matrix for each process("<<n<<"*"<<m<<"matrix)[Max]:"<<endl;
    for(i=0;i<n;i++)
        for(j=0;j<m;j++)
            cin>>Max[i][j];
    int temp[100]={0};
    do
    {
        flag=0;
        cout<<"Please enter the amount of resources allocated by each process("<<n<<"*"<<m<<"matrix)[Allocation]:"<<endl;
        for(i=0;i<n;i++)
        for(j=0;j<m;j++)
        {
            cin>>Allocation[i][j];
            if(Allocation[i][j]>Max[i][j]) flag=1;
            Need[i][j]=Max[i][j]-Allocation[i][j];
            temp[j]+=Allocation[i][j];
        }
        if(flag==1)
        cout<<"The requested resource is greater than the maximum demand, please re-enter!";
        cout<<endl;
        }while(flag);
        for(j=0;j<m;j++)
            Avaliable[j]=Avaliable[j]-temp[j];
}



/********
显示资源分配矩阵
********/
void showdata()
{
    int i,j;
    cout<<"*************************************************************"<<endl;
    cout<<"Resources currently available in the system[Avaliable]:"<<endl;
    for(i=0;i<M;i++)
        cout<<NAME[i]<<" ";
    cout<<endl;
    for (j=0;j<M;j++)
        cout<<Avaliable[j]<<" ";//输出分配资源
    cout<<endl;
    cout<<"The current resource allocation of the system is as follows:"<<endl;
    cout<<"           Max      Allocation     Need"<<endl;
    cout<<"Process name     ";
    for(j=0;j<3;j++)
    {
    for(i=0;i<M;i++)
        cout<<NAME[i]<<" ";
    cout<<"      ";
    }
    cout<<endl;
    for(i=0;i<N;i++)
    {
        cout<<" P"<<i<<"         ";
        for(j=0;j<M;j++)
            cout<<Max[i][j]<<" ";
        cout<<"      ";
        for(j=0;j<M;j++)
            cout<<Allocation[i][j]<<" ";
        cout<<"      ";
        for(j=0;j<M;j++)
            cout<<Need[i][j]<<" ";
        cout<<endl;
    }
}
/********
安全性算法
********/
int safe()
{
    int i,j,k=0,n,apply;
    int Finish[100]={0};
    for (j=0;j<N;j++)
        Work[j]=Avaliable[j];
    for(i=0;i<N;i++)
    {
        apply=0;
        for(j=0;j<M;j++)
        {
            if (Finish[i]==False&&Need[i][j]<=Work[j])
            {
                apply++;
                if(apply==M)
                {
                    for(n=0;n<M;n++)
                    Work[n]=Work[n]+Allocation[i][n];//变分配数
                    Finish[i]=True;
                    Security[k]=i;
                    i=-1;
                    k++;
                }
            }
        }
    }
    for(i=0;i<N;i++)
    {
        if(Finish[i]==False)
        {
            cout<<"The system is insecure and has been paralyzed"<<endl;//不成功系统不安全
            return -1;
        }
    }
    cout<<"The system is safe!"<<endl;//如果安全，输出成功
    cout<<"There is a safe sequence:";
    for(i=0;i<N;i++)
    {//输出运行进程数组
        cout<<"P"<<Security[i];
        if(i<N-1) cout<<"->";
    }
    cout<<endl;
    return 0;
}

/********
尝试分配资源
********/
int test(int i)//进行资源分配
{
    int j;
    for (j=0;j<N;j++)
    {
        Avaliable[j]=Avaliable[j]-Request[j];
        Allocation[i][j]=Allocation[i][j]+Request[j];
        Need[i][j]=Need[i][j]-Request[j];
    }
    return 1;
}
/********
利用银行家算法对申请资源对进行试分配
********/
void bank()
{
    char ch;
    int i,j;
    ch='y';
    cout<<"Please enter the process number requesting the allocation of resources(0-"<<N-1<<"):";
    cin>>i;//输入须申请资源的进程号
    cout<<"Please enter process P"<<i<<"Number of resources to apply:"<<endl;
    for(j=0;j<M;j++)
    {
        cout<<NAME[j]<<":";
        cin>>Request[j];//输入需要申请的资源
    }
    for (j=0;j<M;j++)
    {
        if(Request[j]>Need[i][j])//判断申请是否大于需求，若大于则出错
        {
            cout<<"Process P"<<i<<"The requested resources are greater than the resources it needs";
            cout<<" The allocation is unreasonable and will not be allocated!"<<endl;
            ch='m';
            break;
        }
        else
        {
            if(Request[j]>Avaliable[j])//判断申请是否大于当前可分配资源，若大于则出错
            {
                cout<<"process"<<i<<"The requested resources are greater than the resources currently available in the system";
                cout<<endl;
                cout<<" The system does not have enough resources and will not be allocated!"<<endl;
                ch='m';
                break;
            }
        }
    }
    if(ch=='y')
    {
        test(i);//根据进程需求量变换资源
        showdata();//根据进程需求量显示变换后的资源
        safe();//根据进程需求量进行银行家算法判断
    }
}

int main()//主函数
{
    char choice;
    cout<<"\t---------------------------------------------------"<<endl;
    cout<<"\t||                                               ||"<<endl;
    cout<<"\t||   Implementation of Banker's Algorithm        ||"<<endl;
    cout<<"\t||                                               ||"<<endl;
    cout<<"\t||                                               ||"<<endl;
    cout<<"\t||   Enter your name here: XXX  ||"<<endl;
    cout<<"\t||                                               ||"<<endl;
    cout<<"\t---------------------------------------------------"<<endl;
    chushihua();//初始化数据
    showdata();//显示各种资源
    safe();//用银行家算法判定系统是否安全
    while(choice)
    {
        cout<<"*************************************************************"<<endl;
        cout<<endl;
        cout<<endl;
        cout<<"\t------------------Banker's algorithm demo----------"<<endl;
        cout<<"                     R(r):Request allocation   "<<endl;
        cout<<"                     E(e):quit       "<<endl;
        cout<<"\t---------------------------------------------------"<<endl;
        cout<<"please choose:";
        cin>>choice;
        switch(choice)
        {
            case 'r':
            case 'R':
                bank();break;
            case 'e':
            case 'E':
                choice=0;break;
            default: cout<<"Please choose!"<<endl;break;
        }
    }
}