计算机考研408-操作系统-银行家算法

计算机考研408-操作系统-银行家算法

一、算法用途

避免死锁

二、算法背景

在现实生活的银行中，由于资金有限，客户申请贷款的数量也是有限的，每个客户在第一次申请贷款时要声明完成该项目所需的最大资金量，在满足所有贷款要求后，客户应及时归还贷款。银行家需要在客户申请的贷款数量不超过自己拥有的最大值时，都应尽量满足客户的需要。在计算机中，操作系统就好比银行家，资源就是资金，要申请资源的进程就相当于客户。银行家算法允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性。

三、算法原理

在银行家算法中，系统中的资源被分为不同类型，每个进程对这些资源有一定的需求。当一个进程请求资源时，系统会检查是否有足够的资源可用，以及分配给该进程后系统是否仍然处于安全状态。如果分配资源后系统会进入不安全状态，那么系统将拒绝分配资源，以避免可能导致死锁的情况发生。银行家算法通过动态地检查资源的分配情况，以及对未来可能的资源需求进行预测，来判断系统是否处于安全状态。如果系统处于安全状态，那么资源将被分配给进程；否则，资源分配将被延迟，直到系统重新进入安全状态。

四、算法优、缺点

1. 优点

银行家算法能够避免死锁，确保系统资源的有效利用。

2. 缺点

银行家算法需要提前知道每个进程的最大资源需求、资源分配必须是静态的等。因此，在实际应用中，银行家算法通常作为其他死锁避免策略的一部分来使用。

五、题目解析

如上表所示
P0、P1、P2、P3、P4：系统中目前运行的5个进程；
Max：进程对每个资源的最大需求；
Allocation：进程已经被分配的各类资源的数目；
Need：进程目前还需要的各类资源数目；
Available：系统中总共可以用的各资源的数目；
第一步，分析Available可知，目前可分配的资源有3个A资源、3个B资源和2个C资源；
第二步，分析Need可知，目前可分配资源可以满足请求的进程是：P1需要1个A资源、2个B资源和2个C资源；P3需要1个B资源和1个C资源，两个进程，满足其一即可；
第三步，在第二步选择满足P1进程之后（即Available减去1个A资源、2个B资源和2个C资源），Available还剩余的资源有：2个A资源、1个B资源。P1进入安全序列。P1进程完毕后会释放P1占有的所有资源（即Available加上3个A资源、2个B资源和2个C资源），此时Available还剩余的资源有：5个A资源、3个B资源和2个C资源；
·此时安全序列《P1》
第四步，再次回到第二步分析Need，目前可分配资源（Available还剩余的资源有：5个A资源、3个B资源和2个C资源）可以满足请求的进程是：P3需要1个B资源和1个C资源；P4需要4个A资源、3个B资源和1个C资源，两个进程，满足其一即可；
第五步，在第四步选择满足P3进程之后（即Available减去1个B资源和1个C资源），Available还剩余的资源有：5个A资源、2个B资源和1个C资源。P3进入安全序列。P3进程完毕后会释放P3占有的所有资源（即Available加上2个A资源、2个B资源和2个C资源），此时Available还剩余的资源有：7个A资源、4个B资源和3个C资源；
·此时安全序列《P1、P3》
第六步，再次回到第二步分析Need，目前可分配资源（Available还剩余的资源有：7个A资源、4个B资源和3个C资源）可以满足请求的进程是：P4需要4个A资源、3个B资源和1个C资源；P0需要7个A资源、4个B资源和3个C资源；P2需要6个A资源，三个进程，满足其一即可；
第七步，在第六步选择满足P4进程之后（即Available减去4个A资源、3个B资源和1个C资源），Available还剩余的资源有：3个A资源、1个B资源和2个C资源。P4进入安全序列。P4进程完毕后会释放P4占有的所有资源（即Available加上4个A资源、3个B资源和3个C资源），此时Available还剩余的资源有：7个A资源、4个B资源和5个C资源；
·此时安全序列《P1、P3、P4》
第八步，再次回到第二步分析Need，目前可分配资源（Available还剩余的资源有：7个A资源、4个B资源和5个C资源）可以满足请求的进程是：P0需要7个A资源、4个B资源和3个C资源；P2需要6个A资源，两个进程，满足其一即可；
第九步，在第八步选择满足P0进程之后（即Available减去7个A资源、4个B资源和3个C资源），Available还剩余的资源有：2个C资源。P0进入安全序列。P0进程完毕后会释放P0占有的所有资源（即Available加上7个A资源、5个B资源和3个C资源），此时Available还剩余的资源有：7个A资源、5个B资源和5个C资源；
·此时安全序列《P1、P3、P4、P0》
第十步，再次回到第二步分析Need，目前可分配资源（Available还剩余的资源有：7个A资源、5个B资源和5个C资源）可以满足请求的进程是：P2需要6个A资源；
第十一步，在第十步选择满足P2进程之后（即Available减去6个A资源），Available还剩余的资源有：1个A资源、5个B资源和5个C资源。P2进入安全序列。P2进程完毕后会释放P2占有的所有资源（即Available加上9个A资源和2个C资源），此时Available还剩余的资源有：10个A资源、5个B资源和7个C资源；
·此时安全序列《P1、P3、P4、P0、P2》
至此，所有进程均可安全运行，安全序列为P1->P3->P4->P0->P2
但是，我们在分析过程中发现，在第二步，我们也可以先选择给P3分配资源，同时，在第四步可以选择给P4分配资源，也可以在第六步选择给P0或者P2分配资源，也可以选择在第八步选择给P2分配资源，所以，银行家算法给出的安全序列在本题并不唯一，下面给出所有安全序列，供参考：
1 ：P1->P3->P4->P0->P2
2 ：P1->P3->P4->P2->P0
3 ：P1->P4->P3->P0->P2
4 ：P1->P4->P3->P2->P0
5 ：P3->P1->P0->P2->P4
6 ：P3->P1->P0->P4->P2
7 ：P3->P1->P2->P0->P4
8 ：P3->P1->P2->P4->P0
9 ：P3->P1->P4->P0->P2
10：P3->P1->P4->P2->P0
11：P3->P4->P1->P0->P2
12：P3->P4->P1->P2->P0
（注：
Max = Allocation + Need
进程释放资源后的Available = 当前的Available - Need + Max
即 进程释放资源后的Available = 当前的Available + Allocation

计算过程中一定要很细心）

六、代码实现

#include <stdio.h>

#define DCB 5 //行
#define YXB 3 //列

int main() {
    // 初始化资源Available
    int available[DCB] = {3, 3, 2};

    // 初始化最大需求矩阵Max
    int max[DCB][YXB] = {
        {7, 5, 3},  
   		{3, 2, 2},  
    	{9, 0, 2},  
    	{2, 2, 2},  
    	{4, 3, 3} 
    };

    // 初始化已分配矩阵Allocation
    int allocation[DCB][YXB] = {
        {0, 1, 0},  
    	{2, 0, 0},  
    	{3, 0, 2},  
    	{2, 1, 1},  
    	{0, 0, 2}  
    };
	int need[DCB][YXB]; 
	
    // 计算需求矩阵
    for (int i = 0; i < DCB; i++) {
        for (int j = 0; j < YXB; j++) {
            need[i][j] = max[i][j] - allocation[i][j];
        }
    }

    // 检查系统是否处于安全状态
    int finish[DCB] = {0};
    int work[YXB];
    for (int i = 0; i < YXB; i++) {
        work[i] = available[i];
    }

    int safe_sequence[DCB];
    int count = 0;
    int found = 1;

    while (found) {
        found = 0;
        for (int i = 0; i < DCB; i++) {
            if (!finish[i]) {
                int j;
                for (j = 0; j < YXB; j++) {
                    if (need[i][j] > work[j]) {
                        break;
                    }
                }
                if (j == YXB) {
                    for (int k = 0; k < YXB; k++) {
                        work[k] += allocation[i][k];
                    }
                    finish[i] = 1;
                    safe_sequence[count++] = i;
                    found = 1;
                }
            }
        }
    }

    if (count == DCB ) {
        printf("系统处于安全状态，安全序列为：");
        for (int i = 0; i < DCB ; i++) {
            printf(" P%d", safe_sequence[i]);
        }
        printf("\n");
    } else {
        printf("系统处于不安全状态\n");
    }

    return 0;
}