银行家算法C语言代码

银行家算法

一、银行家算法原理：
我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。
　　为保证资金的安全,银行家规定:
　　(1) 当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客;
　　(2) 顾客可以分期贷款,但贷款的总数不能超过最大需求量;
　　(3) 当银行家现有的资金不能满足顾客尚需的贷款数额时,对顾客的贷款可推迟支付,但总能使顾客在有限的时间里得到贷款;
(4) 当顾客得到所需的全部资金后,一定能在有限的时间里归还所有的资金.
操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。当进程在执行中继续申请资源时，先测试该进程本次申请的资源数是否超过了该资源所剩余的总量。若超过则拒绝分配资源，若能满足则按当前的申请量分配资源，否则也要推迟分配。
二、实验步骤：
1.银行家算法
进程i发出请求资源申请，
(1)如果Request [j]<=need[i,j],转向步骤(2),否则认为出错，因为他所需要的资源数已经超过它所宣布的最大值。
(2)如果：Request i[j]<=available[i,j]，转向步骤(3)，否则表示尚无足够资源，进程i需等待。
(3)若以上两个条件都满足，则系统试探着将资源分配给申请的进程，并修改下面数据结构中的数值：
Available[i,j]= Available[i,j]- Request [j]；
Allocation[i][j]= Allocation[i][j]+ Request [j]；
need[i][j]= need[i][j]- Request [j]；
(4)试分配后，执行安全性检查，调用check()函数检查此次资源分配后系统是否处于安全状态。若安全，才正式将资源分配给进程；否则本次试探分配作废，恢复原来的资源分配状态，让该进程等待。
(5)用do{…}while 循环语句实现输入字符y/n判断是否继续进行资源申请。
2、安全性检查算法
(1)设置两个向量：
工作向量Work，它表示系统可提供给进程继续运行所需的各类资源数目，在执行安全性算法开始时，Work= Available。
工作向量Finish，它表示系统是否有足够的资源分配给进程，使之运行完成。开始时先做Finish[i]=false；当有足够的资源分配给进程时，再令Finish[i]=true。
(2)在进程中查找符合以下条件的进程：
条件1：Finish[i]=false；
条件2：need[i][j]<=Work[j]
若找到，则执行步骤(3)否则，执行步骤(4)
(3)当进程获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：
Work[j]= Work[j]+ Allocation[i][j]；
Finish[i]=true；
goto step (2)；
(4)如果所有的Finish[i]=true都满足，则表示系统处于安全状态，否则，处于不安全状态。
三、银行家算法流程图

四、安全性算法流程图

五、程序源代码：

#include <stdio.h>
int curr[5][5], maxclaim[5][5], avl[5];
int alloc[5] = {0, 0, 0, 0, 0};
int maxres[5], running[5], safe=0;
int count = 0, i, j, exec, r, p, k = 1;
 
int main()
{
    printf("\nEnter the number of processes: ");   //请输入进程数量：5 
    scanf("%d", &p);
 
    for (i = 0; i < p; i++) {
        running[i] = 1;
        count++;
    }
 
    printf("\nEnter the number of resources: ");    //请输入资源数量：4
    scanf("%d", &r);
 
    printf("\nEnter Claim Vector:");     //请输入可利用资源向量：3 12 14 14
    for (i = 0; i < r; i++) { 
        scanf("%d", &maxres[i]);
    }
 
    printf("\nEnter Allocated Resource Table:\n");    //请输入已分配资源矩阵Allocation
    for (i = 0; i < p; i++) { 
        for(j = 0; j < r; j++) {
            scanf("%d", &curr[i][j]);
        }
    }
 
    printf("\nEnter Maximum Claim Table:\n");    //请输入最大需求矩阵Max
    for (i = 0; i < p; i++) {
        for(j = 0; j < r; j++) {
            scanf("%d", &maxclaim[i][j]);
        }
    }
 //
    printf("\nThe Claim Vector is: ");    //打印输出矩阵
    for (i = 0; i < r; i++) {
        printf("\t%d", maxres[i]);
    }
 
    printf("\nThe Allocated Resource Table:\n");
    for (i = 0; i < p; i++) {
        for (j = 0; j < r; j++) {
            printf("\t%d", curr[i][j]);
        }
 
        printf("\n");
    }
 
    printf("\nThe Maximum Claim Table:\n");
    for (i = 0; i < p; i++) {
        for (j = 0; j < r; j++) {
            printf("\t%d", maxclaim[i][j]);
        }
 
        printf("\n");
    }
 
    for (i = 0; i < p; i++) {
        for (j = 0; j < r; j++) {
            alloc[j] += curr[i][j];  //计算所有已分配的总和
        }
    }
 
    printf("\nAllocated resources:");
    for (i = 0; i < r; i++) {
        printf("\t%d", alloc[i]);  //输出总分配资源
    }
 
    for (i = 0; i < r; i++) {
        avl[i] = maxres[i] - alloc[i];   //计算剩余可利用资源量
    }
 
    printf("\nAvailable resources:");  //输出
    for (i = 0; i < r; i++) {
        printf("\t%d", avl[i]);
    }
    printf("\n");
 
    //执行安全性算法
    while (count != 0) {
        safe = 0;
        for (i = 0; i < p; i++) {
            if (running[i]) {
                exec = 1;
                for (j = 0; j < r; j++) {
                    if (maxclaim[i][j] - curr[i][j] > avl[j]) {    
                        exec = 0;
                        break;
                    }
                }
                if (exec) {
                    printf("\nProcess%d is executing\n", i + 1);
                    running[i] = 0;
                    count--;
                    safe = 1;
 
                    for (j = 0; j < r; j++) {
                        avl[j] += curr[i][j];
                    }
 
                    break;
                }
            }
        }
        if (!safe) {
            printf("\nThe processes are in unsafe state.\n");
            break;
        } else {
            printf("\nThe process is in safe state");
            printf("\nAvailable vector:");
 
            for (i = 0; i < r; i++) {
                printf("\t%d", avl[i]);
            }
 
            printf("\n");
        }
    }

六、程序运行调试结果：
附上运行结果

Enter the number of processes: 5

Enter the number of resources: 4

Enter Claim Vector:3 12 14 14

Enter Allocated Resource Table: 0 0 3 2 1 0 0 0 1 3 5 4 0 3 3 2 0 0 1
4

Enter Maximum Claim Table: 0 0 4 4 2 7 5 0 3 6 10 10 0 9 8 4 0 6 6 10

The Claim Vector is: 3 12 14 14 The Allocated
Resource Table:
0 0 3 2
1 0 0 0
1 3 5 4
0 3 3 2
0 0 1 4

The Maximum Claim Table:
0 0 4 4
2 7 5 0
3 6 10 10
0 9 8 4
0 6 6 10

Allocated resources: 2 6 12 12 Available
resources: 1 6 2 2

Process1 is executing

The process is in safe state Available vector: 1 6 5
4

Process4 is executing

The process is in safe state Available vector: 1 9 8
6

Process2 is executing

The process is in safe state Available vector: 2 9 8
6

Process3 is executing

The process is in safe state Available vector: 3 12
13 10

Process5 is executing

The process is in safe state Available vector: 3 12
14 14

非原创，参考log.csdn.net/qq_39404258/article/details/81806560
仅作记录