多级反馈队列调度算法代码c语言

多级反馈队列调度算法是一种常见的进程调度算法，可以根据进程的优先级和运行状态来动态调整进程的执行顺序。下面是一个简单的C语言代码，实现了多级反馈队列调度算法：

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

#define MAX_PROCESS 5

// 进程结构体
typedef struct process {
    int pid;  // 进程ID
    int burst_time;  // 运行时间
    int priority;  // 优先级
    int remaining_time;  // 剩余时间
    int queue;  // 队列级别
    int quantum;  // 时间片
} Process;

// 队列结构体
typedef struct queue {
    Process* processes[MAX_PROCESS];
    int front;
    int rear;
} Queue;

// 初始化队列
void initQueue(Queue* q) {
    q->front = 0;
    q->rear = -1;
}

// 判断队列是否为空
int isEmpty(Queue* q) {
    return q->rear < q->front;
}

// 入队操作
void enqueue(Queue* q, Process* p) {
    if (q->rear >= MAX_PROCESS - 1) {
        printf("队列已满，无法插入新的进程\n");
        return;
    }
    q->rear++;
    q->processes[q->rear] = p;
}

// 出队操作
Process* dequeue(Queue* q) {
    if (isEmpty(q)) {
        printf("队列为空，无法出队\n");
        return NULL;
    }
    Process* p = q->processes[q->front];
    q->front++;
    return p;
}

// 执行进程
void executeProcess(Process* p, int execution_time) {
    p->remaining_time -= execution_time;
    if (p->remaining_time <= 0) {
        printf("进程 %d 执行完毕\n", p->pid);
    } else {
        printf("进程 %d 继续执行，剩余时间 %d\n", p->pid, p->remaining_time);
    }
}

// 多级反馈队列调度算法
void multilevelFeedbackScheduling(Process* processes, int num_processes, int time_slice) {
    Queue queues[3];
    initQueue(&queues[0]);
    initQueue(&queues[1]);
    initQueue(&queues[2]);

    // 初始化进程，并入队到第一个队列
    for (int i = 0; i < num_processes; i++) {
        processes[i].remaining_time = processes[i].burst_time;
        processes[i].queue = 0;
        processes[i].quantum = time_slice;
        enqueue(&queues[0], &processes[i]);
    }

    while (!isEmpty(&queues[0]) || !isEmpty(&queues[1]) || !isEmpty(&queues[2])) {
        if (!isEmpty(&queues[0])) {
            Process* p = dequeue(&queues[0]);
            executeProcess(p, p->quantum);

            if (p->remaining_time <= 0) {
                continue;
            }

            if (p->quantum > 0) {
                p->queue = 1;
                enqueue(&queues[1], p);
            } else {
                p->queue = 2;
                enqueue(&queues[2], p);
            }
        } else if (!isEmpty(&queues[1])) {
            Process* p = dequeue(&queues[1]);
            executeProcess(p, p->quantum);

            if (p->remaining_time <= 0) {
                continue;
            }

            if (p->quantum > 0) {
                p->queue = 1;
                enqueue(&queues[1], p);
            } else {
                p->queue = 2;
                enqueue(&queues[2], p);
            }
        } else {
            Process* p = dequeue(&queues[2]);
            executeProcess(p, p->quantum);

            if (p->remaining_time > 0) {
                p->queue = 2;
                enqueue(&queues[2], p);
            }
        }
    }
}

int main() {
    Process processes[5] = {
        {1, 10, 1, 0, 0, 0},
        {2, 5, 0, 0, 0, 0},
        {3, 8, 1, 0, 0, 0},
        {4, 2, 2, 0, 0, 0},
        {5, 6, 0, 0, 0, 0}
    };

    multilevelFeedbackScheduling(processes, 5, 2);

    return 0;
}

以上代码实现了一个简单的多级反馈队列调度算法。在main函数中定义了5个进程，并调用`multilevelFeedbackScheduling`函数进行调度。其中，进程的`burst_time`表示运行时间，`priority`表示优先级，`queue`表示队列级别，`quantum`表示时间片。通过执行`make`命令进行编译运行，在执行过程中会输出进程的执行情况。