操作系统实验银行家算法c语言代码

下面是一个简单的 C 语言实现银行家算法的代码：

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

// 定义最大进程数和资源数
#define MAX_PROCESS 10
#define MAX_RESOURCE 10

// 进程结构体
typedef struct process {
    int id;                    // 进程 ID
    int allocation[MAX_RESOURCE];    // 当前占用资源
    int max_demand[MAX_RESOURCE];    // 最大需求资源
    int need[MAX_RESOURCE];      // 还需要的资源
    bool finished;              // 进程是否完成
} Process;

// 系统资源结构体
typedef struct system_resource {
    int available[MAX_RESOURCE];      // 系统可用资源数量
    int max_resources[MAX_RESOURCE];  // 系统总资源数量
} SysResource;

// 初始化系统资源
void init_sys_resource(SysResource *sys_res) {
    printf("请输入系统资源总量：");
    for (int i = 0; i < MAX_RESOURCE; i++) {
        scanf("%d", &sys_res->max_resources[i]);
        sys_res->available[i] = sys_res->max_resources[i];
    }
}

// 初始化进程
void init_process(Process *processes, int process_num, int resource_num) {
    printf("请输入每个进程的最大需求量和当前已占用量：\n");
    for (int i = 0; i < process_num; i++) {
        processes[i].id = i;
        processes[i].finished = false;
        printf("进程 %d：\n", i);
        for (int j = 0; j < resource_num; j++) {
            scanf("%d", &processes[i].max_demand[j]);
            scanf("%d", &processes[i].allocation[j]);
            processes[i].need[j] = processes[i].max_demand[j] - processes[i].allocation[j];
        }
    }
}

// 判断当前请求的资源是否合法
bool is_safe_state(SysResource *sys_res, Process *processes, int process_num, int resource_num, int id, int *request) {
    int work[MAX_RESOURCE];
    bool finish[MAX_PROCESS];

    for (int i = 0; i < MAX_RESOURCE; i++) {
        work[i] = sys_res->available[i];
    }

    for (int i = 0; i < MAX_PROCESS; i++) {
        finish[i] = processes[i].finished;
    }

    for (int i = 0; i < MAX_RESOURCE; i++) {
        if (request[i] > processes[id].need[i] || request[i] > sys_res->available[i]) {
            return false;
        }
    }

    for (int i = 0; i < MAX_RESOURCE; i++) {
        processes[id].allocation[i] += request[i];
        processes[id].need[i] -= request[i];
        sys_res->available[i] -= request[i];
        work[i] = sys_res->available[i];
    }

    while (true) {
        bool flag = false;
        for (int i = 0; i < MAX_PROCESS; i++) {
            if (!finish[i]) {
                bool can_finish = true;
                for (int j = 0; j < MAX_RESOURCE; j++) {
                    if (processes[i].need[j] > work[j]) {
                        can_finish = false;
                        break;
                    }
                }
                if (can_finish) {
                    finish[i] = true;
                    flag = true;
                    for (int j = 0; j < MAX_RESOURCE; j++) {
                        work[j] += processes[i].allocation[j];
                    }
                }
            }
        }
        if (!flag) {
            break;
        }
    }

    for (int i = 0; i < MAX_RESOURCE; i++) {
        processes[id].allocation[i] -= request[i];
        processes[id].need[i] += request[i];
        sys_res->available[i] += request[i];
    }

    for (int i = 0; i < MAX_PROCESS; i++) {
        if (!finish[i]) {
            return false;
        }
    }

    return true;
}

// 请求资源
void request_resource(SysResource *sys_res, Process *processes, int process_num, int resource_num) {
    int id;
    int request[MAX_RESOURCE];

    printf("请输入请求资源的进程 ID：");
    scanf("%d", &id);

    printf("请输入请求的资源量：");
    for (int i = 0; i < MAX_RESOURCE; i++) {
        scanf("%d", &request[i]);
    }

    if (is_safe_state(sys_res, processes, process_num, resource_num, id, request)) {
        printf("该请求是安全的，已分配资源！\n");

        for (int i = 0; i < MAX_RESOURCE; i++) {
            sys_res->available[i] -= request[i];
            processes[id].allocation[i] += request[i];
            processes[id].need[i] -= request[i];
        }
    } else {
        printf("该请求不安全，无法分配资源！\n");
    }
}

// 释放资源
void release_resource(SysResource *sys_res, Process *processes, int process_num, int resource_num) {
    int id;
    int release[MAX_RESOURCE];

    printf("请输入释放资源的进程 ID：");
    scanf("%d", &id);

    printf("请输入释放的资源量：");
    for (int i = 0; i < MAX_RESOURCE; i++) {
        scanf("%d", &release[i]);
    }

    for (int i = 0; i < MAX_RESOURCE; i++) {
        processes[id].allocation[i] -= release[i];
        processes[id].need[i] += release[i];
        sys_res->available[i] += release[i];
    }

    printf("资源已释放！\n");
}

// 显示当前资源状态
void display_resource(SysResource *sys_res, Process *processes, int process_num, int resource_num) {
    printf("当前系统资源状态：\n");
    printf("可用资源量：");
    for (int i = 0; i < MAX_RESOURCE; i++) {
        printf("%d ", sys_res->available[i]);
    }
    printf("\n");

    printf("最大资源量：");
    for (int i = 0; i < MAX_RESOURCE; i++) {
        printf("%d ", sys_res->max_resources[i]);
    }
    printf("\n");

    printf("进程占用资源量：\n");
    for (int i = 0; i < process_num; i++) {
        printf("进程 %d：", processes[i].id);
        for (int j = 0; j < resource_num; j++) {
            printf("%d ", processes[i].allocation[j]);
        }
        printf("\n");
    }
}

int main() {
    SysResource sys_res;
    Process processes[MAX_PROCESS];
    int process_num, resource_num;

    printf("请输入进程数：");
    scanf("%d", &process_num);

    printf("请输入资源数：");
    scanf("%d", &resource_num);

    init_sys_resource(&sys_res);
    init_process(processes, process_num, resource_num);

    while (true) {
        printf("\n请选择要进行的操作：\n");
        printf("1. 请求资源\n");
        printf("2. 释放资源\n");
        printf("3. 显示当前资源状态\n");
        printf("4. 退出\n");

        int choice;
        scanf("%d", &choice);

        switch (choice) {
            case 1:
                request_resource(&sys_res, processes, process_num, resource_num);
                break;
            case 2:
                release_resource(&sys_res, processes, process_num, resource_num);
                break;
            case 3:
                display_resource(&sys_res, processes, process_num, resource_num);
                break;
            case 4:
                return 0;
            default:
                printf("请输入正确的操作！\n");
        }
    }
}

这个代码实现了银行家算法的基本功能，包括初始化系统资源和进程，请求资源，释放资源，显示当前资源状态等。需要注意的是，这个代码只是一个简单的示例，并没有考虑多线程等实际情况下的实现细节。