操作系统（2）抢占式短进程优先调度算法模拟实现

1. 效果展示

2. 程序流程图

3. 数据结构设计

（1）进程控制块PCB定义

（2） 进程存储结构定义

4. 功能函数设计

序号	函数	功能说明
1	void process_controller();	进程调度控制函数：接收用户指令并响应
2	void print_menu();	打印命令菜单
3	void create_process();	创建进程
4	void query_process();	查看进程
5	void close_process();	关闭进程
6	void run_process();	运行进程
7	int find_minTime_process();	寻找最短进程
8	void print_process(PCB process);	打印单个进程具体信息
9	bool check_process(int check_processId);	检查该进程号是否已存在

5. 代码实现

/// 进程调度算法
#include <bits/stdc++.h>
#include <windows.h>
using namespace std;

/*
* 设计目的：
*
* [1] 设计可用于该实验的进程控制块，进程控制块包括：进程号、要求服务时间、剩余服务时间、进程优先级、进程是否完成
*
* [2] 动态创建多个进程
*
* [3] 模拟操作系统的 可抢占式短作业优先 进程调度算法
*
* [4] 调度所创建的进程并显示调度结果
*/


/// 数据结构声明
// 进程控制块
typedef struct Process_Control_Block
{
    // 进程号
    int processId;
    // 进程要求服务时间
    int processServeTime;
    // 进程剩余服务时间
    int processRemainingTime;
    // 进程是否完成
    bool processIsFinished;
} PCB;

/// 函数声明
// 进程控制器
void process_controller();
//打印命令菜单
void print_menu();
//创建进程
void create_process();
// 查看进程
void query_process();
// 关闭进程
void close_process();
// 运行进程
void run_process();
// 寻找最短作业的进程
int find_minTime_process();
// 打印单个进程
void print_process(PCB process);
// 检查该进程号是否已存在
bool check_process(int check_processId);

/// 全局变量声明
// 进程容器
vector<PCB> processList;

int main()
{
    cout<<"欢迎使用可抢占式短进程优先调度算法模拟系统！"<<endl;
    process_controller();
    return 0;
}

void print_menu()
{
    cout<<endl;
    cout << "+-------------------------------+" << endl;
    cout << "|\t>>> 命令菜单 <<<\t|" << endl;
    cout << "|\t1.创建新进程\t\t|" << endl;
    cout << "|\t2.查看所有进程\t\t|" << endl;
    cout << "|\t3.关闭进程\t\t|" << endl;
    cout << "|\t4.运行进程\t\t|" << endl;
    cout << "|\t0.退出\t\t\t|" << endl;
    cout << "+-------------------------------+" << endl;
}

void process_controller()
{
    print_menu();
    cout<<"请选择您要进行的操作：";
    int order;
    cin>>order;
    switch(order)
    {
    case 1:
        create_process();
        break;
    case 2:
        query_process();
        break;
    case 3:
        close_process();
        break;
    case 4:
        run_process();
        break;
    case 0:
        cout<<"正在退出..."<<endl;
        Sleep(1000);
        cout<<"安全退出，欢迎下次使用！"<<endl;
        exit(0);
        break;
    default:
        cout<<"不存在此命令，请重试！"<<endl;
    }
    process_controller();
}

void create_process()
{
    PCB process;

    cout << "请输入该进程的进程号：";
    int input_processId;
    cin>>input_processId;
    if(check_process(input_processId)==false)
    {
        cout<<"错误：该进程号已存在！"<<endl;
        return;
    }
    else
    {
        process.processId = input_processId;
        process.processIsFinished = false;

        cout << "请输入该进程需要的服务时间：";
        cin>>process.processServeTime;
        process.processRemainingTime = process.processServeTime;

        cout << "进程创建成功！"<<endl;

        processList.push_back(process);
    }
}

bool check_process(int check_processId)
{
    int len = processList.size();
    for(int i=0; i<len; i++)
    {
        if(processList[i].processId == check_processId)
        {
            return false;
        }
    }
    return true;
}

void query_process()
{
    cout << endl << "| 进程号\t| 服务时间\t| 剩余时间\t| 进程状态\t|" << endl;

    for(int i=0; i<processList.size(); i++)
    {
        print_process(processList[i]);
    }

}

void close_process()
{
    cout<<"请输入您要关闭的进程号：";
    int closedProcessId;
    cin>>closedProcessId;
    for(int i=0; i<processList.size(); i++)
    {
        if(processList[i].processId == closedProcessId)
        {
            processList[i].processIsFinished = true;
            processList[i].processRemainingTime = 0;
            cout<<"进程"<<closedProcessId<<"已成功关闭！"<<endl;
            return;
        }
    }
    cout<<"不存在此进程！";
}

void run_process()
{
    int target_processIndex = find_minTime_process();
    if(target_processIndex == -1)
    {
        cout<<"所有进程均已执行完毕！"<<endl;
        return;
    }

    // 先打印信息，再执行进程
    print_process(processList[target_processIndex]);

    // 剩余服务时间减少
    processList[target_processIndex].processRemainingTime--;

    if(processList[target_processIndex].processRemainingTime==0)
        processList[target_processIndex].processIsFinished = true;
}

void print_process(PCB process)
{
    string processState = process.processIsFinished ? "已结束" : "未结束" ;

    cout << "| 进程\t" << process.processId << "\t| " << process.processServeTime
         << "\t\t| " << process.processRemainingTime << "\t\t| "
         << processState << "\t|" << endl;
}

int find_minTime_process()
{
    int overCnt = 0;
    int minTime_processIndex = 0;
    int minTime = processList[0].processRemainingTime;

    for(int i=0; i<processList.size(); i++)
    {
        if(processList[i].processIsFinished)
            overCnt++;

        if(processList[i].processRemainingTime>=minTime)
        {
            minTime = processList[i].processRemainingTime;
            minTime_processIndex = i;
        }
    }

    if(overCnt == processList.size())
        return -1;
    else
        return minTime_processIndex;
}