优先级调度算法C++

优先级调度算法是一种用于操作系统进程调度的算法。它根据进程的优先级来确定执行顺序，优先级较高的进程会被优先执行。下面是一个简单的优先级调度算法的伪代码示例:

1. 初始化就绪队列和优先级队列
2. 循环直到就绪队列为空:
3.     从就绪队列中选择优先级最高的进程
4.     执行该进程
5.     更新进程的优先级（如果需要）
6.     将执行完的进程从就绪队列中移除
7. 结束循环

在这个算法中，首先需要初始化就绪队列和优先级队列。就绪队列用于存储可以立即执行的进程，而优先级队列用于按照优先级进行排序。然后，不断选择优先级最高的进程执行，执行完毕后更新进程的优先级，并将执行完的进程从就绪队列中移除。最后，当就绪队列为空时结束循环。

相关问题

动态优先级调度算法c++

动态优先级调度算法通常用于实时操作系统(RTOS)中，它可以根据任务的实际运行情况动态调整每个任务的优先级。在C++中，虽然没有直接内置这种算法，但你可以通过自定义数据结构、队列和定时器等机制来模拟。

一种常见的实现方式是结合`std::priority_queue`（优先级队列）和`boost::asio`（一个异步I/O库），例如：

1. **创建任务结构体**：定义一个任务结构体，包含任务标识符、执行函数、当前优先级以及到期时间等信息。

struct Task {
   std::function<void()> fn;
   int priority;
   time_point<> deadline;
};

2. **优先级队列**：使用`std::priority_queue`存储任务，优先级高的任务先执行。

std::priority_queue<Task, std::vector<Task>, std::greater<Task>> taskQueue;

3. **添加任务**：将新任务加入队列，并更新其优先级或到期时间。
4. **调度循环**：定期检查队列顶部的任务，如果任务尚未过期且满足执行条件，就调用其执行函数；否则调整优先级或延后执行时间。

**动态调整优先级的例子**：

void schedule(Task& t, int newPriority) {
   if (t.deadline > now()) {
      t.priority = newPriority; // 更新任务优先级
      taskQueue.update(t); // 调整队列中的优先级
   }
}

编制时间片轮转调度算法和静态优先级调度算法C++

时间片轮转调度算法的C++代码如下：

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

using namespace std;

class Process {
public:
    int pid;
    int arrival_time;
    int burst_time;
    int remaining_time;

    Process(int pid, int arrival_time, int burst_time) {
        this->pid = pid;
        this->arrival_time = arrival_time;
        this->burst_time = burst_time;
        this->remaining_time = burst_time;
    }

    int execute(int time_slice) {
        if (remaining_time > time_slice) {
            remaining_time -= time_slice;
            return time_slice;
        } else {
            int time_executed = remaining_time;
            remaining_time = 0;
            return time_executed;
        }
    }
};

double round_robin_scheduling(vector<Process>& processes, int time_slice) {
    int n = processes.size();
    vector<Process> remaining_processes = processes;
    int current_time = 0;
    int waiting_time = 0;
    int turnaround_time = 0;

    while (!remaining_processes.empty()) {
        Process current_process = remaining_processes[0];
        remaining_processes.erase(remaining_processes.begin());
        if (current_process.arrival_time > current_time) {
            current_time = current_process.arrival_time;
        }
        int time_executed = current_process.execute(time_slice);
        current_time += time_executed;
        if (current_process.remaining_time == 0) {
            waiting_time += current_time - current_process.arrival_time - current_process.burst_time;
            turnaround_time += current_time - current_process.arrival_time;
        } else {
            remaining_processes.push_back(current_process);
        }
    }

    double avg_waiting_time = (double) waiting_time / n;
    double avg_turnaround_time = (double) turnaround_time / n;
    return avg_waiting_time;
}

静态优先级调度算法的C++代码如下：

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

using namespace std;

class Process {
public:
    int pid;
    int arrival_time;
    int burst_time;
    int priority;

    Process(int pid, int arrival_time, int burst_time, int priority) {
        this->pid = pid;
        this->arrival_time = arrival_time;
        this->burst_time = burst_time;
        this->priority = priority;
    }

    void execute() {
        burst_time--;
    }
};

double static_priority_scheduling(vector<Process>& processes) {
    int n = processes.size();
    vector<Process> remaining_processes = processes;
    int current_time = 0;
    int waiting_time = 0;
    int turnaround_time = 0;

    while (!remaining_processes.empty()) {
        sort(remaining_processes.begin(), remaining_processes.end(), [](Process p1, Process p2){
            if (p1.priority == p2.priority) {
                return p1.arrival_time < p2.arrival_time;
            } else {
                return p1.priority > p2.priority;
            }
        });
        Process current_process = remaining_processes[0];
        remaining_processes.erase(remaining_processes.begin());
        if (current_process.arrival_time > current_time) {
            current_time = current_process.arrival_time;
        }
        current_process.execute();
        current_time++;
        if (current_process.burst_time == 0) {
            waiting_time += current_time - current_process.arrival_time - current_process.priority;
            turnaround_time += current_time - current_process.arrival_time;
        } else {
            remaining_processes.push_back(current_process);
        }
    }

    double avg_waiting_time = (double) waiting_time / n;
    double avg_turnaround_time = (double) turnaround_time / n;
    return avg_waiting_time;
}