时间片轮算法原理及其C++代码实现

时间片轮转算法是一种常用的调度算法，其基本原理已经在前面的回答中进行了介绍。下面是一个简单的C++代码实现：

#include <iostream>
#include <queue>
#include <vector>
using namespace std;

// 进程结构体
struct Process {
    int id;  // 进程ID
    int priority;  // 进程优先级
    int arrival_time;  // 进程到达时间
    int burst_time;  // 进程需要执行的时间
    int remaining_time;  // 进程剩余执行时间
    int turnaround_time;  // 进程周转时间
    int waiting_time;  // 进程等待时间
    int response_time;  // 进程响应时间
    int finish_time;  // 进程完成时间
};

// 时间片轮转调度算法
void RR(vector<Process>& processes, int time_slice) {
    queue<Process> ready_queue;  // 就绪队列
    int n = processes.size();
    int current_time = 0;  // 当前时间
    int completed = 0;  // 已完成进程数
    int index = 0;  // 进程索引

    // 将所有进程按照到达时间加入就绪队列
    while (index < n && processes[index].arrival_time <= current_time) {
        ready_queue.push(processes[index]);
        index++;
    }

    // 时间片轮转调度
    while (completed < n) {
        if (!ready_queue.empty()) {
            Process current_process = ready_queue.front();
            ready_queue.pop();

            // 更新响应时间
            if (current_process.remaining_time == current_process.burst_time) {
                current_process.response_time = current_time - current_process.arrival_time;
            }

            // 执行时间片
            int execution_time = min(time_slice, current_process.remaining_time);
            current_process.remaining_time -= execution_time;
            current_time += execution_time;

            // 将剩余执行时间不为0的进程加入就绪队列
            while (index < n && processes[index].arrival_time <= current_time) {
                ready_queue.push(processes[index]);
                index++;
            }

            // 将已执行完毕的进程加入完成队列
            if (current_process.remaining_time == 0) {
                current_process.finish_time = current_time;
                current_process.turnaround_time = current_process.finish_time - current_process.arrival_time;
                current_process.waiting_time = current_process.turnaround_time - current_process.burst_time;
                completed++;
            } else {
                ready_queue.push(current_process);
            }
        } else {
            current_time++;
        }
    }
}

int main() {
    // 示例进程列表
    vector<Process> processes = {
        {1, 2, 0, 5},
        {2, 1, 1, 3},
        {3, 3, 2, 8},
        {4, 4, 3, 6},
        {5, 5, 4, 4}
    };

    // 调用时间片轮转算法
    RR(processes, 2);

    // 输出每个进程的周转时间和等待时间
    cout << "Process ID\tTurnaround Time\tWaiting Time" << endl;
    for (const auto& process : processes) {
        cout << process.id << "\t\t" << process.turnaround_time << "\t\t" << process.waiting_time << endl;
    }

    return 0;
}

这段代码中，我们定义了一个进程结构体，并使用队列来模拟就绪队列。在 RR 函数中，我们按照进程的到达时间将所有进程加入就绪队列，然后进行时间片轮转调度，每次从队列头取出一个进程，执行一个时间片，并将剩余时间不为0的进程放回队列尾部。当一个进程的剩余时间为0时，将其加入完成队列，并更新其周转时间和等待时间。最后，我们输出每个进程的周转时间和等待时间。

请注意，这段代码只是一个简单的示例，实际上，时间片轮转算法的实现可能会更加复杂。