c语言银行家算法

今天晚上上操作系统实验，刚刚才把实验报告补完。。。。。。。

#include<stdio.h>
#include<stdlib.h>

#define PRONUM 5

typedef struct {//数据结构是参考网上的写的，保存abc三种资源的数量，以下的矩阵都可以用这个结构体的数组来表示
    int a;
    int b;
    int c;
}sor;

sor max[PRONUM]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};//初始化最大需求矩阵
sor ali[PRONUM]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};//初始化已分配矩阵
sor need[PRONUM]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};//初始化还需要的资源矩阵
sor source={3,3,2};//初始化系统所能提供的资源矩阵

int safeorder[PRONUM];//记录下安全序列

void tryali(int pro,sor *s){//尝试给进程分配资源

    source.a -= s->a;//修改系统可以提供的资源数目，减去刚刚分配给进程的
    source.b -= s->b;
    source.c -= s->c;

    ali[pro].a += s->a;//修改已经分配的资源矩阵，加上刚刚分配给进程的资源
    ali[pro].b += s->b;
    ali[pro].c += s->c;

    need[pro].a -= s->a;//修改need矩阵，减去刚刚分配给进程的资源
    need[pro].b -= s->b;
    need[pro].c -= s->c;
}

void rollback(int pro,sor *s){//将系统资源分配恢复到初始状态

    source.a += s->a;//修改系统可提供的资源数目，重新加上刚刚已经分配给进程的资源
    source.b += s->b;
    source.c += s->c;

    ali[pro].a -= s->a;//修改已分配资源矩阵，减去刚刚分配给进程的资源
    ali[pro].b -= s->b;
    ali[pro].c -= s->c;

    need[pro].a += s->a;//修改need矩阵，重新加回刚刚分配给进程的资源
    need[pro].b += s->b;
    need[pro].c += s->c;
}

int safecheck(){//安全性检查

    sor work=source;//因为是尝试性地分配，故不能直接修改source，而是用work来代替
    int finish[PRONUM]={0,0,0,0,0};//进程在未完成之前finish的值都为0
    int i=0,j=0;//i用来for循环的计数，j用来记录安全序列
    for(i=0;i<PRONUM;i++){
        if(finish[i]==0){//如果进程未完成
            if((need[i].a<=work.a)&&(need[i].b<=work.b)&&(need[i].c<=work.c)){//并且满足申请的资源小于等于系统当前所能提供的资源
                //满足上述条件则表示进程有了可以执行完毕的条件，以下就让进程执行完毕
                work.a += ali[i].a;//回收进程所占有的资源
                work.b += ali[i].b;
                work.c += ali[i].c;
                finish[i]=1;//将finish的值改为1
                safeorder[j++]=i;//在安全序列中记录下进程的标号
                i=-1;//因为不一定每个进程在满足量finish条件后都满足申请资源小于系统提供资源，因此for循环还要从i=0开始扫描
                //因此要把i的值改变，以便重新赋值
            }
        }
    }
    for(i=0;i<PRONUM;i++){//若是所有进程的finish=1，则表示此次分配不会造成死锁，进程都可以顺利完成
        if(finish[i]==0){//如果有一个进程无法完成，则表示此次分配不安全，返回0
            return 0;//
        }
    }
    return 1;//反之，返回1
}

int request(int pro,sor *s){//处理进程当前的资源请求

    if((s->a<=need[pro].a)&&(s->b<=need[pro].b)&&(s->c<=need[pro].c)){//判断进程是否多申请了资源
        if((s->a<=source.a)&&(s->b<=source.b)&&(s->c<=source.c)){//判断当前系统所能提供的资源是否满足进程申请的数量
            tryali(pro,s);//满足以上条件则尝试分配
            if(safecheck()==1){//判断分配后系统是否处于安全状态，如果是，返回1
                return 1;
            }
            else{
                printf("error deadlock!\n");//反之发出错误提示
                printf("rolling back now.......\n");
                rollback(pro,s);//将系统恢复到未分配前的状态
            }
        }
        else {//如果当前系统提供的资源不能满足进程的申请，则出错
            printf("the sources are not enough!\n");
        }
    }
    else {//如果进程申请的资源数大于进程所需要的资源数，则出错
        printf("too much application!\n");
    }
    return 0;//不能完成分配则返回0
}

void show(){//打印出各个矩阵
    printf("*********************source table*****************************\n");
    printf("pro          max          ali          need          source\n");
    printf("        a   b   c     a   b   c     a   b   c     a   b   c    \n");
    printf("p0      %d   %d   %d     %d   %d   %d     %d   %d   %d     %d   %d   %d\n",max[0].a,max[0].b,max[0].c,ali[0].a,ali[0].b,ali[0].c,need[0].a,need[0].b,need[0].c,source.a,source.b,source.c);
    printf("p1      %d   %d   %d     %d   %d   %d     %d   %d   %d   \n",max[1].a,max[1].b,max[1].c,ali[1].a,ali[1].b,ali[1].c,need[1].a,need[1].b,need[1].c);
    printf("p2      %d   %d   %d     %d   %d   %d     %d   %d   %d   \n",max[2].a,max[2].b,max[2].c,ali[2].a,ali[2].b,ali[2].c,need[2].a,need[2].b,need[2].c);
    printf("p3      %d   %d   %d     %d   %d   %d     %d   %d   %d   \n",max[3].a,max[3].b,max[3].c,ali[3].a,ali[3].b,ali[3].c,need[3].a,need[3].b,need[3].c);
    printf("p4      %d   %d   %d     %d   %d   %d     %d   %d   %d   \n",max[4].a,max[4].b,max[4].c,ali[4].a,ali[4].b,ali[4].c,need[4].a,need[4].b,need[4].c);
    printf("********welcome to huazhong agriculture university!*************\n");
}

int main(){
    char ch='y';//作为是否继续分配的条件判断
    printf("check the system\n");
    if(safecheck()==1){//检测当前的系统是否安全
        printf("the system is safe now!\n");
    }
    else{
        printf("the system is not safe now,we will get out!\n");
    }
    do{
        int pro;
        sor s;
        show();//打印出当前的资源分配情况
        printf("please input the number of process and the number of source:\n");
        scanf("%d %d %d %d",&pro,&s.a,&s.b,&s.c);//输入申请资源的进程号以及所需各个资源的数目
        if(request(pro,&s)==1){//处理资源请求
            printf("success!\n");
        }
        else{
            printf("failed!\n");
        }
        printf("continue or not?\n");
        fflush(stdin);
        ch=getchar();
    }while(ch=='y');

}

测试数据：

1 1 1 1   0 7 5 4   4 4 2 1   0 2 2 1

测试结果：

1111 分配成功

0754 申请资源数目大于所需资源数目

4421 申请资源数目大于此时系统所能提供的资源数目

0221 发生死锁