使用c++实现RR调度算法代码详细版

RR (Round Robin) 调度算法是一种公平调度策略，它将CPU时间片均匀地分配给每个进程，每个进程轮流执行一段固定长度的时间，然后切换到下个进程。以下是使用 C++ 实现 RR 算法的一个简化版本：

#include <iostream>
#include <vector>
#include <queue>

// 定义进程类 Process
class Process {
public:
    int pid; // 进程ID
    int burst_time; // 进程运行所需时间

    Process(int id, int time)
        : pid(id), burst_time(time) {}
};

// 定义优先级队列（用于按剩余时间排序）
template<typename T>
struct CompareByRemainingTime {
    bool operator()(const T& a, const T& b) const {
        return a.burst_time - a.time_left < b.burst_time - b.time_left;
    }
};

// Round Robin 调度函数
void round_robin(std::vector<Process>& processes, int quantum) {
    std turnaround_time = 0; // 总周转时间
    for (Process &p : processes) {
        p.time_left = p.burst_time; // 初始时间片剩余量
        priority_queue<Process, std::vector<Process>, CompareByRemainingTime<Process>> pq(p);
        
        while (!pq.empty()) { // 当队列非空时循环
            Process current_process = pq.top(); // 获取剩余时间最少的进程
            pq.pop();

            if (current_process.time_left <= quantum) { // 如果当前进程小于等于量子，则完成调度
                std::cout << "PID " << current_process.pid << " finished in "
                          << current_process.time_left << " time slices\n";
                current_process.time_left = 0; // 更新进程剩余时间为0
                turnaround_time += current_process.burst_time;
            } else { // 否则分配整个量子
                current_process.time_left -= quantum; // 减少剩余时间
                std::cout << "PID " << current_process.pid << " executed for " << quantum << " time slices\n";
                pq.push(current_process); // 推回更新后的进程
                break; // 因为已经分配了量子，所以跳出循环
            }
        }
    }

    std::cout << "Average Turnaround Time: " << turnaround_time / processes.size() << "\n";
}

int main() {
    std::vector<Process> processes = { {1, 3}, {2, 4}, {3, 2} }; // 创建示例进程列表
    round_robin(processes, 2); // 调度，量子时间为2
    return 0;
}

在这个例子中，我们首先创建了一个进程列表，然后使用优先级队列（堆）按照剩余执行时间对进程进行排序。`round_robin` 函数通过不断从队列中取出最短剩余时间的进程，直到它们完成或达到给定的量子时间。每轮调度结束后，都会更新进程的剩余时间并计算周转时间。