【面试题】操作系统之银行家算法（第七篇）

银行家概念

银行家算法是荷兰学者Dijkstra为银行系统设计的，以确保银行在发放现金贷款时，不会发生不能满足所有客户需要的情况。后来该算法被用在操作系统中，用于避免死锁。

核心思想:在进程提出资源申请时，先预判此次分配是否会导致系统进入不安全状态。如果会进入不安全状态，就暂时不答应这次请求，让该进程先阻塞等待。

安全序列，安全状态与不安全状态

安全序列

安全序列是指在银行家算法中，一种满足系统安全性要求的进程执行顺序。它是一种进程执行的序列，使得每个进程都能在其所需资源得到满足时执行，并在执行完毕后释放资源，而不会发生死锁。

在安全序列中，每个进程按照其所需资源的顺序依次执行，并在执行完毕后释放所占用的资源，这样其他进程才能获取到所需的资源。在执行过程中，系统会动态地检查资源的分配情况，以确保没有进程因为资源不足而被阻塞。

通过找到安全序列，可以保证系统在执行过程中不会陷入死锁状态。安全序列的存在意味着系统中的资源分配是合理的，并且可以满足所有进程的需求，从而确保系统的可靠性和稳定性。

银行家算法的主要目标之一就是找到安全序列，以保证系统的安全状态。如果系统存在安全序列，那么可以按照该序列执行进程并满足资源需求。如果系统不存在安全序列，则需要采取相应的措施，如等待或拒绝新的资源请求，直到系统重新进入安全状态或有其他安全的资源分配方案可用。

总结来说，安全序列是指满足系统安全性要求的进程执行顺序，其中每个进程都能在其所需资源得到满足时执行，并在执行完毕后释放资源，而不会发生死锁。银行家算法的目标之一是找到安全序列，以保证系统的安全状态。

安全状态

安全状态是指在银行家算法中，系统可以找到一种执行顺序（安全序列），使得每个进程都能在其所需资源得到满足时执行，并在执行完毕后释放资源，而不会发生死锁。

当系统处于安全状态时，系统可以有效地分配和管理资源，保证每个进程都能完成执行，并且没有进程因为资源不足而被阻塞。也就是说，存在一种资源分配的顺序，使得每个进程都能按照其最大需求量顺利执行，然后释放占用的资源，同时满足其他进程的需求。

安全状态的特征是存在一个安全序列，即一个进程执行序列，使得系统中的每个进程都能按照其需求得到满足，并在最终释放资源后结束执行。在安全序列中，系统能够满足每个进程对资源的需求，且没有进程会被阻塞或陷入死锁。

通过检查系统的安全性，银行家算法可以确定是否可以安全地分配资源，并避免系统陷入死锁状态。如果系统处于安全状态，新的资源请求可以被满足；如果系统处于不安全状态，则会拒绝新的资源请求，直到系统重新进入安全状态或有其他安全的资源分配方案可用。

总结来说，安全状态是指系统能够找到一种执行顺序，使得每个进程都能在其所需资源得到满足时执行，并在执行完毕后释放资源，而不会发生死锁。银行家算法通过检查系统的安全性来保证资源的有效分配和避免死锁的发生。

不安全状态

不安全状态是指在银行家算法中，系统无法找到一种执行顺序（安全序列），使得每个进程都能在其所需资源得到满足时执行，并在执行完毕后释放资源，可能导致死锁的发生。

不安全状态下，不一定会产生死锁，比如有进程提前归还了一些资源，那么系统可能会重新回到安全状态。

不安全状态下的系统可能陷入死锁，即多个进程互相等待对方所占用的资源，导致它们都无法继续执行。因此，银行家算法的目标是通过检查系统的安全性，确保系统始终处于安全状态，避免死锁的发生。

当系统处于不安全状态时，银行家算法会拒绝新的资源请求，直到系统重新进入安全状态或者有其他安全的资源分配方案可用。

总结来说，不安全状态指的是系统无法找到一种执行顺序，使得每个进程都能在其所需资源得到满足时执行，并在执行完毕后释放资源，可能导致死锁的发生。银行家算法的目标是确保系统始终处于安全状态，避免死锁的发生。

银行家代码

#include <stdio.h>
#include <stdlib.h>
 
#define TRUE 1
#define FALSE 0
#define MAX_PROCESSES 5
#define MAX_RESOURCES 3
 
int available[MAX_RESOURCES] = {3, 3, 2}; // 可用资源数目
int max[MAX_PROCESSES][MAX_RESOURCES] = {
    {7, 5, 3},
    {3, 2, 2},
    {9, 0, 2},
    {2, 2, 2},
    {4, 3, 3}
}; // 每个进程对资源的最大需求
int allocation[MAX_PROCESSES][MAX_RESOURCES] = {
    {0, 1, 0},
    {2, 0, 0},
    {3, 0, 2},
    {2, 1, 0},
    {0, 0, 2}
}; // 每个进程已分配的资源数目
int need[MAX_PROCESSES][MAX_RESOURCES]; // 每个进程还需要的资源数目
 
void initialize_need() {
    int i, j;
    for (i = 0; i < MAX_PROCESSES; i++) {
        for (j = 0; j < MAX_RESOURCES; j++) {
            need[i][j] = max[i][j] - allocation[i][j];
        }
    }
}
 
int is_safe() {
    int work[MAX_RESOURCES];
    int finish[MAX_PROCESSES];
    int i, j, k;
 
    // 初始化标记数组
    for (i = 0; i < MAX_PROCESSES; i++) {
        finish[i] = FALSE;
    }
 
    // 工作向量
    for (i = 0; i < MAX_RESOURCES; i++) {
        work[i] = available[i];
    }
 
    // 检查安全性
    for (i = 0; i < MAX_PROCESSES; i++) {
        if (finish[i] == FALSE) {
            // 检查是否所有需要的资源都被满足
            for (j = 0; j < MAX_RESOURCES; j++) {
                if (need[i][j] > work[j]) {
                    break;
                }
            }
 
            // 如果资源满足，则继续安全性检查
            if (j == MAX_RESOURCES) {
                finish[i] = TRUE;
                for (k = 0; k < MAX_RESOURCES; k++) {
                    work[k] += allocation[i][k];
                }
                i = -1; // 重新开始安全性检查
            }
        }
    }
 
    // 检查是否所有进程都被标记为安全
    for (i = 0; i < MAX_PROCESSES; i++) {
        if (finish[i] == FALSE) {
            return FALSE;
        }
    }
 
    return TRUE;
}
 
int main() {
    initialize_need();
    if (is_safe()) {
        printf("系统是安全的\n");
    } else {
        printf("系统不安全\n");
    }
    return 0;
}