C语言实验一个银行家算法

银行家算法（Banker's Algorithm）是一种操作系统资源分配算法，用于避免死锁。下面是一个简单的用C语言实现的银行家算法：

#include <stdio.h>
#include <stdbool.h>

// 定义最大资源数量和进程数量
#define MAX_RES 5
#define MAX_PROC 4

// 定义可用资源向量，进程最大需求矩阵，进程已分配资源矩阵，进程还需要资源矩阵
int available[MAX_RES];
int max[MAX_PROC][MAX_RES];
int allocation[MAX_PROC][MAX_RES];
int need[MAX_PROC][MAX_RES];

// 定义进程是否完成标志数组，初始化为false
bool finish[MAX_PROC] = { false };

// 输入函数
void input() {
    printf("请输入资源数量：");
    for (int i = 0; i < MAX_RES; i++) {
        scanf("%d", &available[i]);
    }

    printf("请输入进程最大需求矩阵：\n");
    for (int i = 0; i < MAX_PROC; i++) {
        for (int j = 0; j < MAX_RES; j++) {
            scanf("%d", &max[i][j]);
        }
    }

    printf("请输入进程已分配资源矩阵：\n");
    for (int i = 0; i < MAX_PROC; i++) {
        for (int j = 0; j < MAX_RES; j++) {
            scanf("%d", &allocation[i][j]);
        }
    }

    // 计算进程还需要资源矩阵
    for (int i = 0; i < MAX_PROC; i++) {
        for (int j = 0; j < MAX_RES; j++) {
            need[i][j] = max[i][j] - allocation[i][j];
        }
    }
}

// 检查进程是否满足请求
bool check(int pid, int request[]) {
    for (int i = 0; i < MAX_RES; i++) {
        if (request[i] > need[pid][i]) {
            printf("请求的资源数量超过了进程的最大需求量！\n");
            return false;
        }

        if (request[i] > available[i]) {
            printf("当前没有足够的资源可分配！\n");
            return false;
        }
    }

    return true;
}

// 分配资源给进程
void allocate(int pid, int request[]) {
    for (int i = 0; i < MAX_RES; i++) {
        available[i] -= request[i];
        allocation[pid][i] += request[i];
        need[pid][i] -= request[i];
    }
}

// 回收进程的资源
void release(int pid) {
    for (int i = 0; i < MAX_RES; i++) {
        available[i] += allocation[pid][i];
        allocation[pid][i] = 0;
        need[pid][i] = 0;
    }

    finish[pid] = true;
}

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

    int count = 0;
    while (count < MAX_PROC) {
        bool found = false;
        for (int i = 0; i < MAX_PROC; i++) {
            if (!finish[i]) {
                bool enough = true;
                for (int j = 0; j < MAX_RES; j++) {
                    if (need[i][j] > work[j]) {
                        enough = false;
                        break;
                    }
                }

                if (enough) {
                    found = true;
                    finish[i] = true;
                    for (int j = 0; j < MAX_RES; j++) {
                        work[j] += allocation[i][j];
                    }

                    count++;
                    printf("进程 %d 执行完毕后系统处于安全状态：", i);
                    for (int j = 0; j < MAX_RES; j++) {
                        printf("%d ", work[j]);
                    }
                    printf("\n");
                }
            }
        }

        if (!found) {
            printf("系统处于不安全状态！\n");
            return false;
        }
    }

    printf("系统处于安全状态！\n");
    return true;
}

int main() {
    input();

    while (true) {
        int pid;
        int request[MAX_RES];

        printf("请输入请求资源的进程号和资源数量：");
        scanf("%d", &pid);
        for (int i = 0; i < MAX_RES; i++) {
            scanf("%d", &request[i]);
        }

        if (check(pid, request)) {
            allocate(pid, request);
            if (is_safe()) {
                printf("资源分配成功！\n");
            } else {
                printf("资源分配失败，撤销分配！\n");
                release(pid);
            }
        }
    }

    return 0;
}

以上代码实现了一个简单的银行家算法，用户可以输入资源数量、进程最大需求矩阵、进程已分配资源矩阵，并通过输入进程号和请求资源数量进行资源分配。在分配资源前会检查进程是否满足请求，如果满足则进行资源分配，并检查系统是否处于安全状态。如果系统处于安全状态，则资源分配成功，否则撤销分配。