用C语言编写程序完成单处理器系统的进程调度，要求采用时间片轮转法调度策略。具体内容： 1、 确定PCB内容及其组织方式； 2、 要求模拟进程空闲（新）、就绪、运行、阻塞和完成5个状态； 3、 实现进程创建、进程调度、进程阻塞和进程唤醒4个原语； 编写主函数对整个系统进程测试

以下是使用C语言实现单处理器系统的进程调度的代码示例：

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

#define MAX_PROCESS 10
#define TIME_SLICE 2

int current_time = 0; // 当前时间
int current_process = -1; // 当前正在运行的进程的编号

// 进程控制块结构体
typedef struct PCB {
    int pid; // 进程编号
    int status; // 进程状态：0-空闲，1-就绪，2-运行，3-阻塞，4-完成
    int arrival_time; // 进程到达时间
    int burst_time; // 进程执行时间
    int remaining_time; // 进程剩余执行时间
    int wait_time; // 进程等待时间
} PCB;

PCB process_table[MAX_PROCESS]; // 进程表

// 创建进程
void create_process(int pid, int arrival_time, int burst_time) {
    process_table[pid].pid = pid;
    process_table[pid].status = 0;
    process_table[pid].arrival_time = arrival_time;
    process_table[pid].burst_time = burst_time;
    process_table[pid].remaining_time = burst_time;
    process_table[pid].wait_time = 0;
}

// 进程调度
void schedule() {
    int i;
    // 找到最早到达的就绪进程
    int earliest_ready = -1;
    for (i = 0; i < MAX_PROCESS; i++) {
        if (process_table[i].status == 1) { // 就绪状态
            if (earliest_ready == -1 || process_table[i].arrival_time < process_table[earliest_ready].arrival_time) {
                earliest_ready = i;
            }
        }
    }
    if (current_process != -1 && process_table[current_process].remaining_time > 0) { // 当前进程未完成
        process_table[current_process].status = 1; // 放回就绪队列
    }
    if (earliest_ready != -1) { // 有就绪进程
        current_process = earliest_ready;
        process_table[current_process].status = 2; // 运行状态
        process_table[current_process].wait_time += current_time - process_table[current_process].arrival_time; // 计算等待时间
    } else { // 无就绪进程
        current_process = -1;
    }
}

// 进程阻塞
void block_process(int pid) {
    process_table[pid].status = 3; // 阻塞状态
}

// 进程唤醒
void wakeup_process(int pid) {
    process_table[pid].status = 1; // 就绪状态
}

// 主函数
int main() {
    int i, j;
    // 初始化进程表
    for (i = 0; i < MAX_PROCESS; i++) {
        process_table[i].pid = i;
        process_table[i].status = 0;
        process_table[i].arrival_time = -1;
        process_table[i].burst_time = -1;
        process_table[i].remaining_time = -1;
        process_table[i].wait_time = -1;
    }
    // 创建进程
    create_process(0, 0, 3);
    create_process(1, 1, 5);
    create_process(2, 2, 2);
    create_process(3, 3, 4);
    create_process(4, 4, 6);
    // 进程调度
    while (1) {
        int all_done = 1; // 是否所有进程均已完成
        for (i = 0; i < MAX_PROCESS; i++) {
            if (process_table[i].status != 4) { // 进程未完成
                all_done = 0;
                break;
            }
        }
        if (all_done) { // 所有进程均已完成
            break;
        }
        schedule();
        if (current_process != -1) {
            printf("时间 %d，进程 %d 开始执行\n", current_time, current_process);
            for (j = 0; j < TIME_SLICE; j++) {
                current_time++;
                process_table[current_process].remaining_time--;
                if (process_table[current_process].remaining_time == 0) { // 进程完成
                    process_table[current_process].status = 4; // 完成状态
                    printf("时间 %d，进程 %d 完成\n", current_time, current_process);
                    break;
                }
            }
            if (process_table[current_process].remaining_time > 0) { // 时间片用完，进程被抢占
                printf("时间 %d，进程 %d 时间片用完，被抢占\n", current_time, current_process);
                process_table[current_process].status = 1; // 放回就绪队列
            }
        } else {
            current_time++;
        }
    }
    // 输出进程等待时间
    printf("进程等待时间：\n");
    for (i = 0; i < MAX_PROCESS; i++) {
        printf("进程 %d：%d\n", i, process_table[i].wait_time);
    }
    return 0;
}

该程序使用时间片轮转法调度策略，每个进程被分配一个时间片，时间片用完后进程被抢占并放回就绪队列。进程表中的状态分别为0-空闲，1-就绪，2-运行，3-阻塞，4-完成。在主函数中创建了5个进程，分别为：

进程0，到达时间0，执行时间3

进程1，到达时间1，执行时间5

进程2，到达时间2，执行时间2

进程3，到达时间3，执行时间4

进程4，到达时间4，执行时间6

程序输出了每个进程开始执行和完成的时间，并在程序结束后输出了每个进程的等待时间。