四种进程调度算法比较分析

FCFS算法
先来先服务(FCFS)算法是一种最简单的进程调度算法。它按照进程到达的时间顺序进行调度，先到达的进程先执行。FCFS算法的优点是实现简单，开销小。它的缺点是可能导致长进程饿死，即长进程一直等待短进程执行完才能执行。

#include <iostream>
#include <vector>

using namespace std;

// 进程控制块
struct Process {
    int pid;        // 进程ID
    int arrivalTime; // 到达时间
    int burstTime;   // 执行时间
};

// 进程比较函数
bool compareArrivalTime(const Process& p1, const Process& p2) {
    return p1.arrivalTime < p2.arrivalTime;
}

// 先来先服务算法
void fcfs(vector<Process>& processes) {
    // 按照到达时间排序
    sort(processes.begin(), processes.end(), compareArrivalTime);

    // 循环执行进程
    int currentTime = 0;
    for (auto& process : processes) {
        // 计算进程的完成时间
        int completionTime = currentTime + process.burstTime;

        // 输出进程信息
        cout << "进程" << process.pid << ": " << process.arrivalTime << " " << process.burstTime << " " << completionTime << endl;

        // 更新当前时间
        currentTime = completionTime;
    }
}

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

    // 执行先来先服务算法
    fcfs(processes);

    return 0;
}

SJF算法

短进程优先(SJF)算法是一种非抢占式调度算法，它按照进程的执行时间进行调度，执行时间最短的进程先执行。SJF算法的优点是能够提高系统的吞吐量和平均周转时间。它的缺点是可能导致长进程饿死。

#include <iostream>
#include <vector>

using namespace std;

// 进程控制块
struct Process {
    int pid;        // 进程ID
    int arrivalTime; // 到达时间
    int burstTime;   // 执行时间
};

// 进程比较函数
bool compareBurstTime(const Process& p1, const Process& p2) {
    return p1.burstTime < p2.burstTime;
}

// 短进程优先算法
void sjf(vector<Process>& processes) {
    // 按照执行时间排序
    sort(processes.begin(), processes.end(), compareBurstTime);

    // 循环执行进程
    int currentTime = 0;
    for (auto& process : processes) {
        // 计算进程的完成时间
        int completionTime = currentTime + process.burstTime;

        // 输出进程信息
        cout << "进程" << process.pid << ": " << process.arrivalTime << " " << process.burstTime << " " << completionTime << endl;

        // 更新当前时间
        currentTime = completionTime;
    }
}

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

    // 执行短进程优先算法
    sjf(processes);

    return 0;
}

SRT算法

最短剩余时间优先(SRT)算法是一种抢占式调度算法，它按照进程的剩余执行时间进行调度，剩余执行时间最短的进程先执行。SRT算法的优点是能够提高系统的吞吐量和平均周转时间。它的缺点是实现复杂，开销大。

#include <iostream>
#include <vector>

using namespace std;

// 进程控制块
struct Process {
    int pid;        // 进程ID
    int arrivalTime; // 到达时间
    int burstTime;   // 执行时间
    int remainingTime; // 剩余执行时间
};

// 进程比较函数
bool compareRemainingTime(const Process& p1, const Process& p2) {
    return p1.remainingTime < p2.remainingTime;
}

// 最短剩余时间优先算法
void srt(vector<Process>& processes) {
    // 按照到达时间排序
    sort(processes.begin(), processes.end(), compareArrivalTime);

    // 创建就绪队列
    vector<Process> readyQueue;

    // 循环执行进程
    int currentTime = 0;
    while (!processes.empty() || !readyQueue.empty()) {
        // 将到达的进程加入就绪队列
        while (!processes.empty() && processes.front().arrivalTime <= currentTime) {
            readyQueue.push_back(processes.front());
            processes.erase(processes.begin());
        }

        // 如果就绪队列为空，则等待下一个进程到达
        if (readyQueue.empty()) {
            currentTime = processes.front().arrivalTime;
            continue;
        }

        // 按剩余执行时间排序就绪队列
        sort(readyQueue.begin(), readyQueue.end(), compareRemainingTime);

        // 执行就绪队列中剩余执行时间最短的进程
        Process& process = readyQueue.front();
        process.remainingTime--;

        // 如果进程执行完毕，则从就绪队列中删除
        if (process.remainingTime == 0) {
            readyQueue.erase(readyQueue.begin());

            // 计算进程的完成时间
            int completionTime = currentTime + process.burstTime;

            // 输出进程信息
            cout << "进程" << process.pid << ": " << process.arrivalTime << " " << process.burstTime << " " << completionTime << endl;
        }

        // 更新当前时间
        currentTime++;
    }
}

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

    // 执行最短剩余时间优先算法
    srt(processes);

    return 0;
}

RR算法

时间片轮转(RR)算法是一种抢占式调度算法，它将时间划分为固定长度的时间片，每个进程在每个时间片中执行一段时间，然后转到下一个进程，依此循环，直到所有进程执行完毕。RR算法的优点是能够保证每个进程都能够得到公平的执行机会，并且能够防止长进程饿死。它的缺点是开销较大，并且可能会导致进程频繁切换，从而降低系统的性能。

#include <iostream>
#include <vector>

using namespace std;

// 进程控制块
struct Process {
    int pid;        // 进程ID
    int arrivalTime; // 到达时间
    int burstTime;   // 执行时间
    int remainingTime; // 剩余执行时间
};

// 时间片长度
const int timeQuantum = 2;

// 时间片轮转算法
void rr(vector<Process>& processes) {
    // 按照到达时间排序
    sort(processes.begin(), processes.end(), compareArrivalTime);

    // 创建就绪队列
    vector<Process> readyQueue;

    // 循环执行进程
    int currentTime = 0;
    while (!processes.empty() || !readyQueue.empty()) {
        // 将到达的进程加入就绪队列
        while (!processes.empty() && processes.front().arrivalTime <= currentTime) {
            readyQueue.push_back(processes.front());
            processes.erase(processes.begin());
        }

        // 如果就绪队列为空，则等待下一个进程到达
        if (readyQueue.empty()) {
            currentTime = processes.front().arrivalTime;
            continue;
        }

        // 执行就绪队列中的进程
        Process& process = readyQueue.front();
        process.remainingTime -= timeQuantum;

        // 如果进程执行完毕，则从就绪队列中删除
        if (process.remainingTime == 0) {
            readyQueue.erase(readyQueue.begin());

            // 计算进程的完成时间