以下是一个用C语言实现的操作系统PCB（进程控制块）实验程序示例，包含中文注释说明：

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

// 定义进程状态枚举
typedef enum {
    READY,      // 就绪态
    RUNNING,    // 运行态
    BLOCKED,    // 阻塞态
    TERMINATED  // 终止态
} ProcessState;

// 定义PCB结构体
typedef struct pcb {
    int pid;                // 进程ID
    char name[20];          // 进程名称
    ProcessState state;     // 进程状态
    int priority;           // 优先级
    int program_counter;    // 程序计数器
    struct pcb* next;       // 指向下一个PCB的指针
} PCB;

// 全局就绪队列头指针
PCB* ready_queue = NULL;

// 创建新PCB
PCB* create_pcb(int pid, const char* name, int priority) {
    PCB* new_pcb = (PCB*)malloc(sizeof(PCB));
    if (new_pcb != NULL) {
        new_pcb->pid = pid;
        strcpy(new_pcb->name, name);
        new_pcb->state = READY;
        new_pcb->priority = priority;
        new_pcb->program_counter = 0;
        new_pcb->next = NULL;
    }
    return new_pcb;
}

// 将PCB添加到就绪队列（尾部插入）
void add_to_ready_queue(PCB* process) {
    if (ready_queue == NULL) {
        ready_queue = process;
    } else {
        PCB* temp = ready_queue;
        while (temp->next != NULL) {
            temp = temp->next;
        }
        temp->next = process;
    }
    process->state = READY;
}

// 从就绪队列移除首进程
PCB* remove_from_ready_queue() {
    if (ready_queue == NULL) return NULL;

    PCB* removed = ready_queue;
    ready_queue = ready_queue->next;
    removed->next = NULL;
    return removed;
}

// 显示就绪队列
void display_ready_queue() {
    PCB* temp = ready_queue;
    printf("\n就绪队列状态:");
    printf("\nPID\t名称\t状态\t优先级\tPC");

    while (temp != NULL) {
        const char* state_str;
        switch (temp->state) {
            case READY: state_str = "就绪"; break;
            case RUNNING: state_str = "运行"; break;
            case BLOCKED: state_str = "阻塞"; break;
            default: state_str = "未知";
        }

        printf("\n%d\t%s\t%s\t%d\t%d",
               temp->pid,
               temp->name,
               state_str,
               temp->priority,
               temp->program_counter);

        temp = temp->next;
    }
    printf("\n");
}

// 简单模拟进程调度
void schedule() {
    if (ready_queue == NULL) {
        printf("\n就绪队列为空！");
        return;
    }

    PCB* running_process = remove_from_ready_queue();
    running_process->state = RUNNING;

    printf("\n>> 正在运行进程: PID=%d, 名称=%s", running_process->pid, running_process->name);

    // 模拟进程执行（增加PC值）
    running_process->program_counter++;

    printf("\n<< 进程执行完成");

    // 放回就绪队列（实际操作系统可能根据状态决定）
    running_process->state = READY;
    add_to_ready_queue(running_process);
}

int main() {
    printf("操作系统PCB模拟实验\n");
    printf("----------------------------------");

    // 创建示例进程
    PCB* p1 = create_pcb(101, "浏览器", 2);
    PCB* p2 = create_pcb(102, "文本编辑器", 1);
    PCB* p3 = create_pcb(103, "音乐播放器", 3);

    // 添加到就绪队列
    add_to_ready_queue(p1);
    add_to_ready_queue(p2);
    add_to_ready_queue(p3);

    // 显示初始状态
    display_ready_queue();

    // 执行三轮调度模拟
    for (int i = 0; i < 3; i++) {
        printf("\n\n--- 调度周期 %d ---", i+1);
        schedule();
        display_ready_queue();
    }

    // 释放内存
    free(p1);
    free(p2);
    free(p3);

    return 0;
}

程序功能说明：

1. PCB结构定义：

   • 包含进程ID、名称、状态、优先级、程序计数器等核心字段
   • 使用链表指针维护进程队列

2. 核心功能模块：

   • create_pcb()：创建新PCB
   • add_to_ready_queue()：加入就绪队列
   • remove_from_ready_queue()：从队列取出进程
   • schedule()：简单调度模拟（FIFO）
   • display_ready_queue()：显示队列状态

3. 状态管理：

   • 使用枚举类型定义四种进程状态
   • 调度时自动更新进程状态

4. 执行流程：

   • 创建三个示例进程
   • 循环演示三轮调度过程
   • 每次调度后显示队列状态变化

实验运行示例：

操作系统PCB模拟实验
----------------------------------
就绪队列状态:
PID     名称    状态    优先级  PC
101     浏览器  就绪    2       0
102     文本编辑器      就绪    1       0
103     音乐播放器      就绪    3       0

--- 调度周期 1 ---
>> 正在运行进程: PID=101, 名称=浏览器
<< 进程执行完成
就绪队列状态:
PID     名称    状态    优先级  PC
102     文本编辑器      就绪    1       0
103     音乐播放器      就绪    3       0
101     浏览器  就绪    2       1

...

扩展实验建议：

1. 实现优先级调度算法
2. 添加阻塞/唤醒机制
3. 增加时间片轮转功能
4. 实现进程创建/终止的完整生命周期
5. 添加资源管理模块（如信号量）

此程序模拟了操作系统中PCB管理的基本原理，可通过添加更多功能模块来构建更完整的进程管理系统。