实验目标

模拟操作系统内核的进程管理功能，包括进程创建/终止、状态转换和内存分配管理。

核心要求

1. 定义进程控制块(PCB)数据结构管理进程信息
2. 通过键盘输入模拟进程状态转换事件
3. 实时显示就绪/执行/阻塞队列状态
4. 实现可选的内存分配回收功能

设计实现

进程控制块设计

struct ProcessControlBlock {
    char processName[10];
    struct ProcessControlBlock* next;
    // 可选扩展: 内存基址/长度字段
};

队列管理函数

// 添加进程到队列尾部
void enqueue(ProcessControlBlock* head, ProcessControlBlock* proc) {
    ProcessControlBlock* current = head;
    while (current->next != NULL) {
        current = current->next;
    }
    current->next = proc;
    proc->next = NULL;
}

// 从队列头部移除进程
ProcessControlBlock* dequeue(ProcessControlBlock* head) {
    ProcessControlBlock* firstProc = head->next;
    if (firstProc != NULL) {
        head->next = firstProc->next;
        firstProc->next = NULL;
    }
    return firstProc;
}

内存管理模型

使用双向链表管理内存分区，每个节点包含：

• 分区状态标记(H=空闲/P=占用)
• 起始地址和长度
• 前后节点指针

内存回收时处理四种合并场景：

1. 单独回收占用分区
2. 与前空闲区合并
3. 与后空闲区合并
4. 同时与前后空闲区合并

完整实现

#include <iostream>
#include <cstdlib>
#include <cstring>
using namespace std;

struct ProcessControlBlock {
    char processName[10];
    ProcessControlBlock* next;
};

ProcessControlBlock* readyQueue;
ProcessControlBlock* blockedQueue;
ProcessControlBlock* activeProcess;

void initializeQueue(ProcessControlBlock** queue) {
    *queue = new ProcessControlBlock();
    (*queue)->next = NULL;
}

void enqueue(ProcessControlBlock* head, ProcessControlBlock* proc) {
    ProcessControlBlock* current = head;
    while (current->next != NULL) current = current->next;
    current->next = proc;
    proc->next = NULL;
}

ProcessControlBlock* dequeue(ProcessControlBlock* head) {
    ProcessControlBlock* first = head->next;
    if (first) {
        head->next = first->next;
        first->next = NULL;
    }
    return first;
}

void createNewProcess() {
    cout << "输入进程名称: ";
    char name[10];
    cin >> name;
    
    ProcessControlBlock* newProc = new ProcessControlBlock();
    strcpy(newProc->processName, name);
    enqueue(readyQueue, newProc);
    
    if (!activeProcess) 
        activeProcess = dequeue(readyQueue);
}

void handleTimeSlice() {
    if (activeProcess) {
        enqueue(readyQueue, activeProcess);
        activeProcess = dequeue(readyQueue);
    } else if (readyQueue->next) {
        activeProcess = dequeue(readyQueue);
    }
}

void blockActiveProcess() {
    if (activeProcess) {
        enqueue(blockedQueue, activeProcess);
        activeProcess = dequeue(readyQueue);
    }
}

void wakeupBlockedProcess() {
    if (blockedQueue->next) {
        ProcessControlBlock* proc = dequeue(blockedQueue);
        enqueue(readyQueue, proc);
        if (!activeProcess) 
            activeProcess = dequeue(readyQueue);
    }
}

void terminateProcess() {
    if (activeProcess) {
        delete activeProcess;
        activeProcess = dequeue(readyQueue);
    }
}

void displaySystemStatus() {
    cout << "\n[执行] ";
    if (activeProcess) cout << activeProcess->processName;
    
    cout << "\n[就绪] ";
    ProcessControlBlock* current = readyQueue->next;
    while (current) {
        cout << current->processName << " ";
        current = current->next;
    }
    
    cout << "\n[阻塞] ";
    current = blockedQueue->next;
    while (current) {
        cout << current->processName << " ";
        current = current->next;
    }
    cout << "\n" << endl;
}

void showMenu() {
    cout << "1.新建进程\t2.时间片结束\n"
         << "3.阻塞进程\t4.唤醒进程\n"
         << "5.终止进程\t6.退出系统\n> ";
}

int main() {
    initializeQueue(&readyQueue);
    initializeQueue(&blockedQueue);
    activeProcess = nullptr;
    
    while (true) {
        displaySystemStatus();
        showMenu();
        
        int choice;
        cin >> choice;
        switch (choice) {
            case 1: createNewProcess(); break;
            case 2: handleTimeSlice(); break;
            case 3: blockActiveProcess(); break;
            case 4: wakeupBlockedProcess(); break;
            case 5: terminateProcess(); break;
            case 6: exit(0);
            default: cout << "无效操作" << endl;
        }
    }
}