时间片轮转调度算法c++

好的，这是一个基于时间片轮转的简单调度算法的C++实现：

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

struct Process {
    int pid;
    int burst_time;
    int remaining_time;
};

void time_slice_round_robin(Process processes[], int n, int time_slice) {
    queue<Process> q;
    int current_time = 0;
    int total_burst_time = 0;
    for (int i = 0; i < n; i++) {
        total_burst_time += processes[i].burst_time;
        processes[i].remaining_time = processes[i].burst_time;
    }
    while (current_time < total_burst_time) {
        for (int i = 0; i < n; i++) {
            if (processes[i].remaining_time > 0) {
                if (processes[i].remaining_time > time_slice) {
                    current_time += time_slice;
                    processes[i].remaining_time -= time_slice;
                    q.push(processes[i]);
                }
                else {
                    current_time += processes[i].remaining_time;
                    processes[i].remaining_time = 0;
                    cout << "Process " << processes[i].pid << " finished at " << current_time << endl;
                }
            }
        }
        while (!q.empty()) {
            Process p = q.front();
            q.pop();
            if (p.remaining_time > 0) {
                if (p.remaining_time > time_slice) {
                    current_time += time_slice;
                    p.remaining_time -= time_slice;
                    q.push(p);
                }
                else {
                    current_time += p.remaining_time;
                    p.remaining_time = 0;
                    cout << "Process " << p.pid << " finished at " << current_time << endl;
                }
            }
        }
    }
}

int main() {
    Process processes[] = { {1, 10}, {2, 5}, {3, 8} };
    int n = sizeof(processes) / sizeof(processes[0]);
    int time_slice = 2;
    time_slice_round_robin(processes, n, time_slice);
    return 0;
}

在这个实现中，我们定义了一个Process结构体表示进程，包含进程ID（pid）、进程执行时间（burst_time）和进程剩余执行时间（remaining_time）。

我们还实现了一个函数time_slice_round_robin来执行调度算法。它使用一个队列来存放当前被挂起的进程，并且在每个时间片结束时检查队列中有没有需要继续执行的进程。如果有，它会把它们放回队列中，并且继续执行下一个进程。

在main函数中，我们定义了一个包含三个进程的进程数组，并且调用time_slice_round_robin函数来执行调度算法。调度算法使用时间片大小为2。