操作系统实验——处理机调度算法的实现

实验内容：

Exercise 1: 设定系统中有五个进程，每一个进程用一个进程控制块表示。

Exercise 2: 输入每个进程的“优先数”和“要求运行时间”。

Exercise 3: 为了调度方便，将五个进程按给定的优先数从大到小连成就绪队列。用一单元指出队列首进程，用指针指出队列的连接情况。

Exercise 4: 处理机调度总是选队首进程运行。采用动态优先数算法，进程每运行一次优先数就减“1”，同时将运行时间减“1”。

Exercise 5: 若某进程运行时间为零，则将其状态置为“结束”,且退出队列。

Exercise 6: 运行所设计程序，显示或打印逐次被选中进程的进程名，以及进程控制块的动态变化过程

1.头文件

#include <iostream>
#include <vector>
#include <algorithm>

#include < vector>
这个头文件提供了std::vector模板类的定义。std::vector是一个序列容器，能够存储具有相同类型的元素的动态数组。与普通的C数组不同，std::vector能够在运行时自动管理存储空间的分配和释放，支持动态地增加或减少元素的数量，并且能够自动处理元素的内存分配。

#include < algorithm>
这个头文件包含了各种算法函数，如排序、搜索、比较、复制、填充、变换等。这些算法可以对容器（如std::vector）中的元素进行操作，但算法本身并不管理容器的内存。算法通常接受迭代器作为参数，允许它们操作不同种类的容器。

2.定义一个结构体，用于表示各个进程

struct Process {
    std::string name;
    int priority;
    int burst_time;
    Process(std::string n, int p, int b) : name(n), priority(p), burst_time(b) {}
};

这个结构体Process中包含了三个部分：进程名（name），优先数（priority），运行时间（burst_time）。
然后定义了一个构造函数名为Process，后续可使用此函数直接定义一个Process结构体，如：
Process p1(“Process1”, 1, 10);
定义了一个结构体名为p1，进程名为Process1，优先数为1，运行时间为10的结构体，在此用为表示一个进程。

3.定义一个类Mu，包含了需要用到的两个方法

类的代码

class Mu{

public:

    void processes_set(std::vector<Process>& processes) {
        for (int i = 0; i < 5; ++i) {
            std::string name;
            int priority, burst_time;

            std::cout << "输入第" << i + 1 << "个进程的名字: ";
            std::cin >> name;

            std::cout << "输入进程 " << name << " 的优先数: ";
            std::cin >> priority;

            std::cout << "输入进程 " << name << " 的运行时间: ";
            std::cin >> burst_time;

            processes.emplace_back(name, priority, burst_time);
        }
    };

    void processes_running(std::vector<Process>& processes) {
        //将进程按优先级排序

        std::sort(processes.begin(), processes.end(), [](const Process& a, const Process& b) {
            return a.priority > b.priority; // 根据优先级从大到小排序
            });

        std::cout << "初始就绪队列：" << std::endl;

        //范围-based for 循环
        for (const auto& p : processes) {
            std::cout << "进程名：" << p.name << " 优先数：" << p.priority << " 运行时间：" << p.burst_time << std::endl;
        }
        //开始运行进程
        while (!processes.empty()) {
            // 选择优先级最高的进程
            Process* running_process = &processes[0];

            std::cout << "选中进程：" << running_process->name << std::endl;

            running_process->priority -= 1;
            running_process->burst_time -= 1;

            std::cout << "被选中后进程变化： 优先数：" << running_process->priority << " 运行时间：" << running_process->burst_time << std::endl;

            if (running_process->burst_time == 0) {
                std::cout << "进程 " << running_process->name << " 运行结束" << std::endl;
                processes.erase(processes.begin());
            }
            else {
                std::sort(processes.begin(), processes.end(), [](const Process& a, const Process& b) {
                    return a.priority > b.priority; // 每次运行后重新排序，以确保优先级高的进程会被选上
                    });
            }
        }

        std::cout << "所有进程执行完毕" << std::endl;

    };

};

（1）.建立进程

void processes_set(std::vector<Process>& processes) {
        for (int i = 0; i < 5; ++i) {
            std::string name;
            int priority, burst_time;

            std::cout << "输入第" << i + 1 << "个进程的名字: ";
            std::cin >> name;

            std::cout << "输入进程 " << name << " 的优先数: ";
            std::cin >> priority;

            std::cout << "输入进程 " << name << " 的运行时间: ";
            std::cin >> burst_time;

            processes.emplace_back(name, priority, burst_time);
        }
    };

创建一个建立进程函数processes_set：
使用for循环，在for循环中建立变量后，提醒用户输入对应变量的值，最后使用.emplace_back方法，将生成的进程插入到std::vector< Process>容器的末尾

（2.）进程运行

void processes_running(std::vector<Process>& processes) {
        //将进程按优先级排序

        std::sort(processes.begin(), processes.end(), [](const Process& a, const Process& b) {
            return a.priority > b.priority; // 根据优先级从大到小排序
            });

        std::cout << "初始就绪队列：" << std::endl;

        //范围-based for 循环
        for (const auto& p : processes) {
            std::cout << "进程名：" << p.name << " 优先数：" << p.priority << " 运行时间：" << p.burst_time << std::endl;
        }
        //开始运行进程
        //当processes容器非空是执行while循环
        while (!processes.empty()) {
            // 选择优先级最高的进程
            Process* running_process = &processes[0];

            std::cout << "选中进程：" << running_process->name << std::endl;

            running_process->priority -= 1;
            running_process->burst_time -= 1;

            std::cout << "被选中后进程变化： 优先数：" << running_process->priority << " 运行时间：" << running_process->burst_time << std::endl;

            if (running_process->burst_time == 0) {
                std::cout << "进程 " << running_process->name << " 运行结束" << std::endl;
                processes.erase(processes.begin());
            }
            else {
                std::sort(processes.begin(), processes.end(), [](const Process& a, const Process& b) {
                    return a.priority > b.priority; // 每次运行后重新排序，以确保优先级高的进程会被选上
                    });
            }
        }

        std::cout << "所有进程执行完毕" << std::endl;

    };

创建一个进程运行函数processes_running：

首先，使用 std::sort 算法对容器 processes 中的 Process 对象进行了从大到小的优先级（priority ）排序。
sort在此处使用的讲解

然后，使用一个范围-based for 循环将排序后的内容循环遍历出来
范围-based for 循环在此处使用的讲解

最后，使用一个while循环实现处理机调度

4.main函数的实现

int main() {
    Mu mu;
    std::vector<Process> processes;

    mu.processes_set(processes);
    mu.processes_running(processes);

    return 0;
}

5.完整代码

#include <iostream>
#include <vector>
#include <algorithm>

struct Process {
    std::string name;
    int priority;
    int burst_time;

    Process(std::string n, int p, int b) : name(n), priority(p), burst_time(b) {}
};

class Mu{

public:

    void processes_set(std::vector<Process>& processes) {
        for (int i = 0; i < 5; ++i) {
            std::string name;
            int priority, burst_time;

            std::cout << "输入第" << i + 1 << "个进程的名字: ";
            std::cin >> name;

            std::cout << "输入进程 " << name << " 的优先数: ";
            std::cin >> priority;

            std::cout << "输入进程 " << name << " 的运行时间: ";
            std::cin >> burst_time;

            processes.emplace_back(name, priority, burst_time);
        }
    };

    void processes_running(std::vector<Process>& processes) {
        //将进程按优先级排序

        std::sort(processes.begin(), processes.end(), [](const Process& a, const Process& b) {
            return a.priority > b.priority; // 根据优先级从大到小排序
            });

        std::cout << "初始就绪队列：" << std::endl;

        //范围-based for 循环
        for (const auto& p : processes) {
            std::cout << "进程名：" << p.name << " 优先数：" << p.priority << " 运行时间：" << p.burst_time << std::endl;
        }
        //开始运行进程
        while (!processes.empty()) {
            // 选择优先级最高的进程
            Process* running_process = &processes[0];

            std::cout << "选中进程：" << running_process->name << std::endl;

            running_process->priority -= 1;
            running_process->burst_time -= 1;

            std::cout << "被选中后进程变化： 优先数：" << running_process->priority << " 运行时间：" << running_process->burst_time << std::endl;

            if (running_process->burst_time == 0) {
                std::cout << "进程 " << running_process->name << " 运行结束" << std::endl;
                processes.erase(processes.begin());
            }
            else {
                std::sort(processes.begin(), processes.end(), [](const Process& a, const Process& b) {
                    return a.priority > b.priority; // 每次运行后重新排序，以确保优先级高的进程会被选上
                    });
            }
        }

        std::cout << "所有进程执行完毕" << std::endl;

    };

};
int main() {
    Mu mu;
    std::vector<Process> processes;

    mu.processes_set(processes);
    mu.processes_running(processes);

    return 0;
}

6.运行结果