C实现银行家算法(避免死锁)

#include <stdlib.h>

#include <stdio.h>

#include <malloc/malloc.h>

#define SourceType 3

#define ProcessNum 5

//第SourceNum类可用资源数:

typedef struct Available{

    int Available[SourceType];

}Ava;

//进程ProcessNum对资源SourceNum类资源的最大需求:

typedef struct Max{

    int Max[ProcessNum][SourceType];

}Max;

//进程ProcessNum已占有资源SourceNum类资源的数量:

typedef struct Allocation{

    int Allocation[ProcessNum][SourceType];

}Alloc;

//进程ProcessNum还需要多少SourceNum资源:

typedef struct Need{

    int Need[ProcessNum][SourceType];

}Need;

int check(Ava * ava,Need * need,Alloc * allo){

    //初始化Finish:

    int Finish[ProcessNum];

    for (int i=0; i<ProcessNum; i++) {

        Finish[i] = 0;

    }

    //初始化Work:

    int Work[SourceType];

    for (int j=0; j<SourceType; j++) {

        Work[j] = ava->Available[j];

    }

    //生成p数组(即安全序列):

    int p[ProcessNum];

    for (int pp = 0; pp<ProcessNum; pp++) {

        p[pp] = 0;

    }

    //复制need:

    Need * needCp = (Need*)malloc(sizeof(Need));

    for (int i=0; i<ProcessNum; i++) {

        for (int j=0; j<SourceType; j++) {

            needCp->Need[i][j] = need->Need[i][j];

        }

    }

    

    for (int ii=0; ii<ProcessNum; ii++) {

        int outCheckSum = 0;

        //从0号进程开始查找:

        for (int i=0; i<ProcessNum; i++) {

            int checkSum = 0;

            for (int j=0; j<SourceType; j++) {

                if (needCp->Need[i][j] <= Work[j]) {

                    checkSum+=1;

                }

            }

            if (checkSum == SourceType) {

                printf(“work = “);

                for (int j=0; j<SourceType; j++) {

                    //使这个进程的need不会再被遍历:

                    needCp->Need[i][j] += 10;

                    printf(” %d “,Work[j]);

                    Work[j] = Work[j] + allo->Allocation[i][j];

                    Finish[i] = 1;

                    p[ii]=i;

                }

                //跳出循环:

                i=ProcessNum;

            }

            outCheckSum = checkSum;

        }

        if (outCheckSum < SourceType) {

            free(needCp);

            return 0;

        }

        printf(“p[ii] = %d \n”,p[ii]);

    }

    free(needCp);

    return 1;

}

int main(int argc, const char * argv[]) {

    /************************** 初始化 ****************************/

    /*已知有3个并发进程共享10个系统资源(因此SourceNum=1,ProcessNum=3)*/

    //初始化系统资源数Available:

    printf(“输入系统原有资源数:\n”);

    Ava * ava = (Ava*)malloc(sizeof(Ava));

    for (int i=0; i<SourceType; i++) {

        scanf(“%d”,&ava->Available[i]);

    }

    //Allocation数组存放各进程申请的各SourceType类的资源数:

    Alloc * allo = (Alloc*)malloc(sizeof(Alloc));

    int sum[SourceType];

    for (int i=0; i<SourceType; i+=1) {

        sum[i] = 0;

    }

    printf(“输入各进程动态申请资源数组:\n”);

    for (int i=0; i<ProcessNum; i++) {

        printf(“进程 %d : \n”,i);

        for (int j=0; j<SourceType; j++) {

            scanf(“%d”,&allo->Allocation[i][j]);

            sum[j] = sum[j] + allo->Allocation[i][j];

        }

    }

    //初始化Max数组,并生成Need数组:

    Max * max = (Max*)malloc(sizeof(Max));

    Need * need = (Need*)malloc(sizeof(Need));

    printf(“输入各进程对于各资源的最大需求:\n”);

    for (int i=0; i<ProcessNum; i++) {

        printf(“进程 %d : \n”,i);

        for (int j=0; j<SourceType; j++) {

            scanf(“%d”,&max->Max[i][j]);

            if (max->Max[i][j] > ava->Available[j]) {

                printf(“申请最大资源数大于系统现有资源数!”);

                return1;

            }else{

                need->Need[i][j] = max->Max[i][j] – allo->Allocation[i][j];

            }

        }

    }

    

    printf(“计算出现有的SourceType类的资源数:\n”);

    for (int i=0; i<SourceType; i++) {

        ava->Available[i] = ava->Available[i] – sum[i];

        printf(” %d “,ava->Available[i]);

    }

    printf(“\n”);

    /************************** 初始安全检测 ****************************/

    int checkResult = check(ava,need,allo);

    if (checkResult) {

        printf(“Safe!\n”);

    }else{

        printf(“Unsafe!\n”);

        return1;

    }

    /************************** 开始运行 ****************************/

    //输入第i号进程的Request向量:

    int Request[SourceType];

    int RequestNum = 0;

    while (RequestNum != –1) {

        //输入第RequestNum号进程申请资源:

        printf(“输入第RequestNum号进程申请资源\n”);

        scanf(“%d”,&RequestNum);

        

        if (RequestNum == –1) break;

        

        //对第j类资源的申请量:

        printf(“输入对第j类资源的申请量:\n”);

        for (int jj=0; jj<SourceType; jj++) {

            scanf(“%d”,&Request[jj]);

        }

        //判断申请量是否合格:

        int checkAll = 0;//如果等于SourceType,说明下面的条件每一类资源都成立:

        for (int jj = 0; jj<SourceType; jj++) {

            if ((Request[jj] <= need->Need[RequestNum][jj]) && (Request[jj] <= ava->Available[jj])) {

                checkAll+= 1;

            }

        }

        //对资源进行试探性分配:

        if (checkAll == SourceType) {

            for (int jj=0; jj<SourceType; jj++) {

                allo->Allocation[RequestNum][jj] = allo->Allocation[RequestNum][jj] + Request[jj];

                need->Need[RequestNum][jj] = need->Need[RequestNum][jj] – Request[jj];

                ava->Available[jj] = ava->Available[jj] – Request[jj];

            }

        }else{

            printf(“不安全!\n”);

            continue;

        }

        //安全检查:

        if (check(ava, need, allo)) {

            printf(“安全!\n”);

        }else{

            printf(“不安全!\n”);

            //撤销刚才的试探性分配:

            for (int jj=0; jj<SourceType; jj++) {

                allo->Allocation[RequestNum][jj] = allo->Allocation[RequestNum][jj] – Request[jj];

                need->Need[RequestNum][jj] = need->Need[RequestNum][jj] + Request[jj];

                ava->Available[jj] = ava->Available[jj] + Request[jj];

            }

        }

    }

    return 0;

}

    原文作者:银行家问题
    原文地址: https://blog.csdn.net/guozirong123/article/details/78866136
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞