银行家算法演示【原创】

/*
名称：银行家算法演示
作者：杜琪
时间：2010.11.14
作用：
演示银行家算法的作用和操作过程：
1、判断此刻系统是否处于安全状态
2、输入某一进程的请求资源，然后利用银行家算法判断是否可以
找到一个安全序列，如果可以，将该进程申请的资源分配出去，
并且输出安全序列。
*/
#include<stdio.h>
#define RN  3//资源的数目为3
#define PN  5//进程数目为5


/*各个函数声明*/
void Init();//初始化界面函数声明
int Banker(int i,int Requist[]);//银行家函数声明
bool Security(int s[],int t[][RN],int p[][RN]);//安全性检查函数声明

void main()
{//主函数，程序入口
    /*初始化银行家算法中所用到的数据结构和变量*/
    int Available[RN]={3,3,2};//可利用资源向量
    int Max[PN][RN]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};//最大需求矩阵，它定义了系统中PN个进程
                                                              //中的每一个进程对RN类资源的最大需求
    int Allocation[PN][RN]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};//分配矩阵，表示当前系统中每一个进程获得的
                                                            //的每一类资源数目
    int Need[PN][RN]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};//表示一个进程上需要的各类资源的数目
    int P1[]={1,0,2};//P1数组存放进程1请求的资源
    int P4[]={3,3,0};
    int P0[]={0,1,0};
    int i=0;//表示哪个进程请求资源
    bool flag1;
    /*问题背景初始化*/
    Init();
    /*判断当前时刻系统是否处于安全状态*/
    flag1=Security(Available,Need,Allocation);
    if(flag1)
    {
        printf("/n");
        printf("当前系统处于安全状态！/n");
    }
    else
    {
        printf("/n");
        printf("当前系统处于不安全状态！/n");
    }
//  进程P1请求资源，Requist(1,0,2)
    i=1;
    Banker(i,P1);
    printf("/n");
/*  进程p4请求资源，Requist(3,3,0)
    i=4;
    Banker(i,P4);
    printf("/n");
    进程p0请求资源，Requist(0,2,0)
    i=0;
    Banker(i,P0);
    进程p0请求资源，Requist(0,1,0) */
}

/*界面初始化函数的定义*/
void Init()
{
    int i,j;
    /*初始化银行家算法中所用到的数据结构和变量*/
    int Available[RN]={3,3,2};//可利用资源向量
    int Max[PN][RN]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};//最大需求矩阵，它定义了系统中PN个进程
                                                              //中的每一个进程对RN类资源的最大需求
    int Allocation[PN][RN]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};//分配矩阵，表示当前系统中每一个进程获得的
                                                            //的每一类资源数目
    int Need[PN][RN]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};//表示一个进程上需要的各类资源的数目
    printf("T0时刻的资源分配图如下:/n");
    printf("各个资源最大需求矩阵如下:/n");
    printf("   A B C/n");
    for(i=0;i<PN;i++)
    {
        printf("p%d:",i);
        for(j=0;j<RN;j++)
            printf("%d ",Max[i][j]);
        printf("/n");
    }
    printf("各个资源分配矩阵如下:/n");
    printf("   A B C/n");
    for(i=0;i<PN;i++)
    {
        printf("p%d:",i);
        for(j=0;j<RN;j++)
            printf("%d ",Allocation[i][j]);
        printf("/n");
    }
    printf("各个资源需求矩阵如下:/n");
    printf("   A B C/n");
    for(i=0;i<PN;i++)
    {
        printf("p%d:",i);
        for(j=0;j<RN;j++)
            printf("%d ",Need[i][j]);
        printf("/n");
    }
    printf("可利用资源向量如下:/n");
    printf("   A B C/n");
    printf("   ");
    for(i=0;i<RN;i++)
    {
        printf("%d ",Available[i]);
    }
    printf("/n");
}

/*银行家算法函数的定义*/
int Banker(int i,int p[])
{
    int Available[RN]={3,3,2};//可利用资源向量
    int Allocation[PN][RN]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};//分配矩阵，表示当前系统中每一个进程获得的
                                                            //的每一类资源数目
    int Need[PN][RN]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};//表示一个进程上需要的各类资源的数目
    int Requist[RN];
    for(int m=0;m<RN;m++)
    {
        Requist[m]=p[m];
    }
    int j;
    bool flag1=1;//
    bool flag2=1;
    bool flag3=1;
    for(j=0;j<RN;j++)
    {
        if(Requist[j]>Need[i][j])
        {
            flag1=0;
            printf("进程%d需要的资源已超过它宣布的最大值!",i);
            break;
        }
    }
    if(flag1)
    {
        for(j=0;j<RN;j++)
        {
            if(Requist[j]>Available[j])
            {
                flag2=0;
                printf("没有足够的资源，进程%d必须等待。",i);
                break;
            }
        }
        if(flag2)
        {
            for(j=0;j<RN;j++)//系统试探着把资源分配给进程i
            {
                Available[j]=Available[j]-Requist[j];
                Allocation[i][j]=Allocation[i][j]+Requist[j];
                Need[i][j]=Need[i][j]-Requist[j];
            }
            flag3=Security(Available,Need,Allocation);//执行安全性检查，当第i个进程发出请求后，如果分配给它它所要的资源，系统是否处于安全状态
            if(flag3)//如果系统处于安全状态，banker()返回1,正式将资源分配给进程i
            {
                return 1;
            }
            else
            {
                //系统处于不安全状态,先将本次的试探分配作废，恢复到原来的资源分配状态
                for(j=0;j<RN;j++)
                {
                    Available[j]=Available[j]+Requist[j];
                    Allocation[i][j]=Allocation[i][j]-Requist[j];
                    Need[i][j]=Need[i][j]+Requist[j];
                }
            }
        }
    }
    return 0;
}

/*安全性检查算法函数的定义*/
bool Security(int Available[],int Need[][RN],int Allocation[][RN])
{
    int bian;
    bool flag1,flag2;
    flag1=true;
    int m,n;
    int Work[RN];
    for(m=0;m<RN;m++)
    {
        Work[m]=Available[m];
    }
    bool Finish[PN]={0,0,0,0,0};
    while(flag1)
    {
        bian=0;
        for(m=0;m<PN;m++)
        {
            flag2=true;
            if(!Finish[m])
            {
                for(n=0;n<RN;n++)
                {
                    if(Need[m][n]>Work[n])
                    {
                        flag2=0;
                        break;
                    }
                }
                if(flag2)
                {
                    bian=1;
                    for(n=0;n<RN;n++)
                    {
                        Work[n]=Work[n]+Allocation[m][n];
                    }
                    printf("p%d/t",m);
                    Finish[m]=true;
                }
            }
        }
        if(bian==0)
        {
            flag1=0;
        }
    }
    return 1;
}