三种算法的模拟:
1、先来先服务算法
2、循环轮转算法
3、多级队列反馈调度算法
#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
using namespace std;
struct PCB {
int id;
int arrive_time;
int run_time;
int need_time;
int finish_time;
PCB* next;
};
queue<PCB> coming_queue;
queue<PCB> wait_queue;
queue<PCB> wait_queue1;
queue<PCB> wait_queue2;
void init_processes() {
int n;
cout << "输入进程数: ";
cin >> n;
vector<PCB> temp_queue;
for (int i = 0; i < n; ++i) {
PCB pcb;
pcb.id = i + 1;
cout << "输入进程 " << pcb.id << " 的到达时间和运行时间: ";
cin >> pcb.arrive_time >> pcb.run_time;
pcb.finish_time = 0;
pcb.need_time = pcb.run_time;
pcb.next = nullptr;
auto it = temp_queue.begin();
while (it != temp_queue.end() && it->arrive_time <= pcb.arrive_time) {
++it;
}
temp_queue.insert(it, pcb);
}
for (const auto& pcb : temp_queue) {
coming_queue.push(pcb);
}
}
void print_process_stats(const vector<PCB>& finished_processes) {
int total_turnaround_time = 0;
cout << "ID\t到达时间\t执行时间\t结束时间\t周转时间\n";
for (const auto& pcb : finished_processes) {
int turnaround_time = pcb.finish_time - pcb.arrive_time;
total_turnaround_time += turnaround_time;
cout << pcb.id << "\t" << pcb.arrive_time << "\t\t" << pcb.run_time << "\t\t"
<< pcb.finish_time << "\t\t" << turnaround_time << "\n";
}
cout << "平均周转时间: " << (total_turnaround_time / finished_processes.size()) << "\n";
}
void fcfs() {
vector<PCB> finished_processes;
int current_time = 0;
while (!coming_queue.empty()) {
PCB pcb = coming_queue.front();
coming_queue.pop();
if (current_time < pcb.arrive_time) {
current_time = pcb.arrive_time;
}
current_time += pcb.run_time;
pcb.finish_time = current_time;
finished_processes.push_back(pcb);
}
print_process_stats(finished_processes);
}
void rr(int time_slice) {
vector<PCB> finished_processes;
int current_time = coming_queue.front().arrive_time;
// 模拟进程的到达,将到达时间在当前时间之前的进程放入等待队列
while (!coming_queue.empty() && coming_queue.front().arrive_time <= current_time) {
wait_queue.push(coming_queue.front());
coming_queue.pop();
}
// 循环执行直到等待队列为空
while (!wait_queue.empty()) {
PCB pcb = wait_queue.front(); // 取出等待队列中的第一个进程
wait_queue.pop();
if (pcb.need_time <= time_slice) {
current_time += pcb.need_time; // 运行完当前时间片
pcb.finish_time = current_time; // 记录完成时间
finished_processes.push_back(pcb); // 将进程加入已完成进程列表
}
else {
current_time += time_slice; // 未运行完一个时间片,更新当前时间
pcb.need_time -= time_slice; // 减去已运行的时间
// 将未完成的进程重新放回等待队列
while (!coming_queue.empty() && coming_queue.front().arrive_time <= current_time) {
wait_queue.push(coming_queue.front());
coming_queue.pop();
}
wait_queue.push(pcb); // 将当前进程放回等待队列
}
}
print_process_stats(finished_processes); // 打印进程统计信息
}
void mlfq(int time_slice) {
const int num_queues = 2; // 定义队列的数量
queue<PCB> wait_queues[num_queues]; // 创建多个等待队列
vector<PCB> finished_processes;
int current_time = coming_queue.front().arrive_time;
while (true) {
// 将到达的进程放入第一个等待队列中
while (!coming_queue.empty() && coming_queue.front().arrive_time <= current_time) {
wait_queues[0].push(coming_queue.front());
coming_queue.pop();
}
bool over = true; //true表示进程都执行完
// 从最高优先级的队列开始处理
for (int i = 0; i < num_queues; ++i) {
if (!wait_queues[i].empty()) {
over = false;
PCB pcb = wait_queues[i].front(); // 取出队首进程
wait_queues[i].pop();
if (current_time < pcb.arrive_time) {
current_time = pcb.arrive_time;
}
//时间更新
int exec_time = min(time_slice, pcb.need_time);
current_time += exec_time;
pcb.need_time -= exec_time;
// 将到达的进程放入第一个等待队列中
while (!coming_queue.empty() && coming_queue.front().arrive_time <= current_time) {
wait_queues[0].push(coming_queue.front());
coming_queue.pop();
}
if (pcb.need_time > 0) {
// 如果进程没有完成,降级到下一个优先级的队列
if (i < num_queues - 1) {
wait_queues[i + 1].push(pcb);
}
else {
wait_queues[i].push(pcb); // 保持在当前队列
}
}
else {
// 进程完成
pcb.finish_time = current_time;
finished_processes.push_back(pcb);
}
break; // 处理一个进程后,跳出内循环重新检查所有队列
}
}
// 如果所有队列都为空并且没有新进程到达,跳出循环
if (over && coming_queue.empty()) {
break;
}
// 如果所有队列都为空但还有新进程未到达,推进时间到下一个进程到达的时间
if (over && !coming_queue.empty()) {
current_time = coming_queue.front().arrive_time;
}
}
print_process_stats(finished_processes); // 打印进程统计信息
}
void menu() {
cout << "选择调度算法:\n";
cout << "1. 先来先服务 (FCFS)\n";
cout << "2. 轮转法 (时间片 = 2)\n";
cout << "3. 多级反馈队列 (时间片 = 2)\n";
cout << "4. 退出\n";
cout << "输入你的选择: ";
}
int main() {
int choice;
while (true) {
init_processes();
menu();
cin >> choice;
switch (choice) {
case 1:
fcfs();
system("pause");
system("cls");
break;
case 2:
rr(2);
system("pause");
system("cls");
break;
case 3:
mlfq(2);
system("pause");
system("cls");
break;
case 4:
return 0;
default:
cout << "无效选择。请重试。\n";
}
}
return 0;
}
运行截图:
先来先服务算法:
轮转法:
多级队列反馈队列: