操作系统：时间片轮转调度算法 实验内容及要求： 已知有三个进程P1、P2、P3，单独完成它们所需的时间为21、6、3，假定时间片S=4，运用时间片轮转调度算法打印出调度序列(用队列实现),请用C语言编写，并给出完整代码

操作系统中的时间片轮转调度算法是一种分时处理机制，每个进程被分配一定的时间片（Time Slice），当它的执行时间到达该时间片后，如果还未完成，就会让给其他等待的进程执行。实验内容要求模拟这个过程，对于已知的进程及其运行时间，按照时间片轮转的方式找出它们的调度顺序。

下面是用C语言实现的一个简单示例，这里我们使用队列来存储进程以及它们的状态（正在运行、就绪）。请注意，这只是一个简化的模型，并未包含所有错误检查和实际系统的细节：

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

typedef struct {
    char* name;
    int time;
    bool running;
} Process;

struct Queue {
    Process* items;
    int count;
};

void enqueue(Process** queue, Process item) {
    if (queue->count == 0) {
        queue->items = malloc(sizeof(Process));
        queue->items[0] = item;
        queue->count++;
    } else {
        Process* new_queue = realloc(queue->items, sizeof(Process) * (queue->count + 1));
        new_queue[queue->count] = item;
        queue->items = new_queue;
        queue->count++;
    }
}

Process dequeue(Process** queue) {
    if (queue->count == 0)
        return (Process){NULL, 0, false};
    Process removed_item = queue->items[0];
    queue->items = realloc(queue->items, sizeof(Process) * (queue->count - 1));
    queue->count--;
    return removed_item;
}

// 时间片轮转函数
void time_slice_schedule(int S, Process processes[], int num_processes) {
    Process current_process;
    Queue* ready_queue = (Queue*)malloc(sizeof(Queue));
    ready_queue->items = NULL;
    ready_queue->count = 0;

    for (int i = 0; i < num_processes; ++i) {
        current_process = processes[i];
        current_process.running = true;
        enqueue(&ready_queue, current_process);
    }

    while (!ready_queue->count == 0) {
        printf("%s ", ready_queue->items->name); // 打印当前运行的进程

        if (ready_queue->items->running && ready_queue->items->time <= S) {
            // 如果时间片结束，移除并就绪
            current_process.time -= S;
            ready_queue->items->running = false;
            printf("ended, %d remaining\n", current_process.time);
        } else { // 还剩下时间，继续执行
            break;
        }

        current_process = dequeue(&ready_queue);
        current_process.running = true;
        enqueue(&ready_queue, current_process);
    }
}

int main() {
    Process processes[] = {
        {"P1", 21, true},
        {"P2", 6, true},
        {"P3", 3, true}
    };
    int num_processes = sizeof(processes) / sizeof(processes[0]);
    int time_slice = 4;

    time_slice_schedule(time_slice, processes, num_processes);

    free(ready_queue->items);
    free(ready_queue);
    return 0;
}