【C语言】级反馈队列调度算法（Multilevel Feedback Queue Scheduling）

多级反馈队列调度算法（Multilevel Feedback Queue Scheduling）是一种操作系统进程调度算法，它将进程分配到不同优先级的队列中，并根据进程的行为动态调整其优先级。以下是用C语言实现多级反馈队列调度算法的简单示例：

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

// 定义进程结构体
typedef struct Process {
    int pid;
    int burst_time;
    int priority;
    int waiting_time;
    int turnaround_time;
} Process;

void schedule(Process *processes, int num_processes, int num_queues, int *quantum);

int main() {
    int num_processes = 5;
    int num_queues = 3;
    int quantum[] = {4, 8, 16}; // 每个队列的时间片长度

    Process processes[] = {
        {1, 10, 1},
        {2, 29, 3},
        {3, 3, 2},
        {4, 7, 1},
        {5, 12, 3}
    };

    schedule(processes, num_processes, num_queues, quantum);

    return 0;
}

void schedule(Process *processes, int num_processes, int num_queues, int *quantum) {
    int time = 0;
    bool done = false;

    // 创建多级队列
    Process **queues = (Process **) malloc(num_queues * sizeof(Process *));
    for (int i = 0; i < num_queues; i++) {
        queues[i] = (Process *) malloc(num_processes * sizeof(Process));
    }

    int *queue_size = (int *) calloc(num_queues, sizeof(int));

    // 将进程放入相应的优先级队列中
    for (int i = 0; i < num_processes; i++) {
        int priority = processes[i].priority - 1;
        queues[priority][queue_size[priority]++] = processes[i];
    }

    while (!done) {
        done = true;

        // 遍历多级队列
        for (int i = 0; i < num_queues; i++) {
            for (int j = 0; j < queue_size[i]; j++) {
                if (queues[i][j].burst_time > 0) {
                    done = false;

                    // 计算实际时间片长度
                    int actual_quantum = (queues[i][j].burst_time > quantum[i]) ? quantum[i] : queues[i][j].burst_time;
                    time += actual_quantum;
                    queues[i][j].burst_time -= actual_quantum;

                    // 计算等待时间和周转时间
                    for (int k = 0; k < num_processes; k++) {
                        if (processes[k].pid != queues[i][j].pid && processes[k].burst_time > 0) {
                            processes[k].waiting_time += actual_quantum;
                            processes[k].turnaround_time += actual_quantum;
                        }
                    }
                }
            }
        }
    }

    // 计算并显示结果
    double total_waiting_time = 0;
    double total_turnaround_time = 0;
    for (int i = 0; i < num_processes; i++) {
        total_waiting_time += processes[i].waiting_time;
        total_turnaround_time += processes[i].turnaround_time + processes[i].
burst_time;

    printf("进程 %d，等待时间 = %d，周转时间 = %d\n", processes[i].pid, processes[i].waiting_time, processes[i].turnaround_time);
}

double avg_waiting_time = total_waiting_time / num_processes;
double avg_turnaround_time = total_turnaround_time / num_processes;

printf("平均等待时间 = %.2lf\n", avg_waiting_time);
printf("平均周转时间 = %.2lf\n", avg_turnaround_time);

// 释放分配的内存
for (int i = 0; i < num_queues; i++) {
    free(queues[i]);
}
free(queues);
free(queue_size);
}


这个示例代码实现了一个简化版的多级反馈队列调度算法，进程根据它们的优先级被放入不同的队列中。代码首先初始化进程数据，然后调用`schedule`函数进行调度。