就绪进程的调度

利用C++语言，模拟处理机调度过程中，选择就绪进程的调度过程。

从先来先服务

#include <iostream>
#include <queue>
#include <vector>

using namespace std;

struct Process {
    int pid;        // 进程ID
    int arrival;    // 到达时间
    int burst;      // 执行时间
};

void FCFS(vector<Process>& processes) {
    queue<Process> readyQueue;
    int currentTime = 0;
    
    // 按到达时间排序
    sort(processes.begin(), processes.end(), [](const Process& a, const Process& b) {
        return a.arrival < b.arrival;
    });

    for (auto& p : processes) {
        readyQueue.push(p);
    }

    while (!readyQueue.empty()) {
        Process current = readyQueue.front();
        readyQueue.pop();

        // 如果当前时间小于进程到达时间，等待
        if (currentTime < current.arrival) {
            currentTime = current.arrival;
        }

        cout << "正在执行进程 " << current.pid 
             << "，到达时间：" << current.arrival
             << "，执行时间：" << current.burst << endl;

        currentTime += current.burst;
        cout << "进程 " << current.pid << " 完成，完成时间：" << currentTime << endl;
    }
}

int main() {
    vector<Process> processes = {
        {1, 0, 5},
        {2, 1, 3},
        {3, 2, 8},
        {4, 3, 6}
    };

    cout << "FCFS 调度过程：" << endl;
    FCFS(processes);

    return 0;
}

优先级调度算法

非抢占式

#include <iostream>
#include <queue>
#include <vector>

using namespace std;

struct Process {
    int pid;        // 进程ID
    int arrival;    // 到达时间
    int burst;      // 执行时间
    int priority;   // 新增：优先级
};

void PriorityScheduling(vector<Process>& processes) {
    // 使用priority_queue作为就绪队列，按优先级排序
    auto cmp = [](const Process& a, const Process& b) {
        return a.priority > b.priority; // 优先级数值越小，优先级越高
    };
    priority_queue<Process, vector<Process>, decltype(cmp)> readyQueue(cmp);
    
    int currentTime = 0;
    
    // 按到达时间排序
    sort(processes.begin(), processes.end(), [](const Process& a, const Process& b) {
        return a.arrival < b.arrival;
    });

    int i = 0;
    while (i < processes.size() || !readyQueue.empty()) {
        // 将已到达的进程加入就绪队列
        while (i < processes.size() && processes[i].arrival <= currentTime) {
            readyQueue.push(processes[i]);
            i++;
        }

        if (!readyQueue.empty()) {
            Process current = readyQueue.top();
            readyQueue.pop();

            cout << "正在执行进程 " << current.pid 
                 << "，到达时间：" << current.arrival
                 << "，执行时间：" << current.burst
                 << "，优先级：" << current.priority << endl;

            currentTime += current.burst;
            cout << "进程 " << current.pid << " 完成，完成时间：" << currentTime << endl;
        } else {
            // 如果没有就绪进程，时间推进到下一个进程到达时间
            currentTime = processes[i].arrival;
        }
    }
}

int main() {
    vector<Process> processes = {
        {1, 0, 5, 2},
        {2, 1, 3, 1},
        {3, 2, 8, 3},
        {4, 3, 6, 2}
    };

    cout << "优先级调度过程：" << endl;
    PriorityScheduling(processes);

    return 0;
}

抢占式

#include <iostream>
#include <queue>
#include <vector>

using namespace std;

struct Process {
    int pid;        // 进程ID
    int arrival;    // 到达时间
    int burst;      // 执行时间
    int priority;   // 新增：优先级
};

void PriorityScheduling(vector<Process>& processes) {
    auto cmp = [](const Process& a, const Process& b) {
        return a.priority > b.priority;
    };
    priority_queue<Process, vector<Process>, decltype(cmp)> readyQueue(cmp);
    
    int currentTime = 0;
    sort(processes.begin(), processes.end(), [](const Process& a, const Process& b) {
        return a.arrival < b.arrival;
    });

    int i = 0;
    Process* currentProcess = nullptr;
    int remainingTime = 0;

    while (i < processes.size() || !readyQueue.empty() || currentProcess) {
        // 将已到达的进程加入就绪队列
        while (i < processes.size() && processes[i].arrival <= currentTime) {
            readyQueue.push(processes[i]);
            i++;
        }

        // 检查是否有更高优先级的进程到达
        if (!readyQueue.empty() && 
            (currentProcess == nullptr || readyQueue.top().priority < currentProcess->priority)) {
            if (currentProcess) {
                // 保存当前进程的剩余执行时间
                readyQueue.push(*currentProcess);
            }
            // 获取新的最高优先级进程
            *currentProcess = readyQueue.top();
            readyQueue.pop();
            remainingTime = currentProcess->burst;
        }

        if (currentProcess) {
            // 执行一个时间单位
            remainingTime--;
            currentTime++;

            if (remainingTime == 0) {
                cout << "进程 " << currentProcess->pid << " 完成，完成时间：" << currentTime << endl;
                currentProcess = nullptr;
            }
        } else {
            // 如果没有就绪进程，时间推进到下一个进程到达时间
            currentTime = processes[i].arrival;
        }
    }
}

int main() {
    vector<Process> processes = {
        {1, 0, 5, 2},
        {2, 1, 3, 1},
        {3, 2, 8, 3},
        {4, 3, 6, 2}
    };

    cout << "优先级调度过程：" << endl;
    PriorityScheduling(processes);

    return 0;
}

 

时间片轮转

#include <iostream>
#include <queue>
#include <vector>

using namespace std;

struct Process {
    int pid;        // 进程ID
    int arrival;    // 到达时间
    int burst;      // 执行时间
    int priority;   // 新增：优先级
};

void PriorityScheduling(vector<Process>& processes) {
    auto cmp = [](const Process& a, const Process& b) {
        return a.priority > b.priority;
    };
    priority_queue<Process, vector<Process>, decltype(cmp)> readyQueue(cmp);
    
    int currentTime = 0;
    sort(processes.begin(), processes.end(), [](const Process& a, const Process& b) {
        return a.arrival < b.arrival;
    });

    int i = 0;
    Process* currentProcess = nullptr;
    int remainingTime = 0;

    while (i < processes.size() || !readyQueue.empty() || currentProcess) {
        // 将已到达的进程加入就绪队列
        while (i < processes.size() && processes[i].arrival <= currentTime) {
            readyQueue.push(processes[i]);
            i++;
        }

        // 检查是否有更高优先级的进程到达
        if (!readyQueue.empty() && 
            (currentProcess == nullptr || readyQueue.top().priority < currentProcess->priority)) {
            if (currentProcess) {
                // 保存当前进程的剩余执行时间
                readyQueue.push(*currentProcess);
            }
            // 获取新的最高优先级进程
            *currentProcess = readyQueue.top();
            readyQueue.pop();
            remainingTime = currentProcess->burst;
        }

        if (currentProcess) {
            // 执行一个时间单位
            remainingTime--;
            currentTime++;

            if (remainingTime == 0) {
                cout << "进程 " << currentProcess->pid << " 完成，完成时间：" << currentTime << endl;
                currentProcess = nullptr;
            }
        } else {
            // 如果没有就绪进程，时间推进到下一个进程到达时间
            currentTime = processes[i].arrival;
        }
    }
}

void RoundRobin(vector<Process>& processes, int timeQuantum) {
    queue<Process> readyQueue;
    int currentTime = 0;
    
    // 按到达时间排序
    sort(processes.begin(), processes.end(), [](const Process& a, const Process& b) {
        return a.arrival < b.arrival;
    });

    int i = 0;
    while (i < processes.size() || !readyQueue.empty()) {
        // 将已到达的进程加入就绪队列
        while (i < processes.size() && processes[i].arrival <= currentTime) {
            readyQueue.push(processes[i]);
            i++;
        }

        if (!readyQueue.empty()) {
            Process current = readyQueue.front();
            readyQueue.pop();

            // 执行时间片
            int executeTime = min(timeQuantum, current.burst);
            cout << "正在执行进程 " << current.pid 
                 << "，执行时间：" << executeTime 
                 << "，剩余时间：" << current.burst - executeTime << endl;

            currentTime += executeTime;
            current.burst -= executeTime;

            // 如果进程还未完成，重新加入队列
            if (current.burst > 0) {
                readyQueue.push(current);
            } else {
                cout << "进程 " << current.pid << " 完成，完成时间：" << currentTime << endl;
            }
        } else {
            // 如果没有就绪进程，时间推进到下一个进程到达时间
            currentTime = processes[i].arrival;
        }
    }
}

int main() {
    vector<Process> processes = {
        {1, 0, 5, 2},
        {2, 1, 3, 1},
        {3, 2, 8, 3},
        {4, 3, 6, 2}
    };

    int timeQuantum = 2; // 时间片长度
    cout << "时间片轮转调度过程（时间片长度：" << timeQuantum << "）：" << endl;
    RoundRobin(processes, timeQuantum);

    return 0;
}