进程调度算法c++五种

常见的进程调度算法有以下五种：

1. 先来先服务（FCFS，First Come First Served）：按照进程到达的顺序进行调度，先到达的进程先执行，直到执行完或者阻塞才进行下一个进程的调度。

2. 最短作业优先（SJF，Shortest Job First）：按照进程的执行时间进行调度，执行时间短的进程优先执行，有利于短作业快速完成，但是可能会导致长作业一直等待。

3. 优先级调度（Priority Scheduling）：按照进程的优先级进行调度，优先级高的进程优先执行，可以通过设置不同的优先级来实现不同的调度策略。

4. 时间片轮转（Round Robin）：按照时间片的大小进行调度，每个进程被分配一个时间片，如果时间片用完则切换到下一个进程，如果进程在时间片内完成，则切换到下一个进程。

5. 多级反馈队列（Multilevel Feedback Queue）：根据进程的特点，将进程划分成多个队列，每个队列拥有不同的优先级和时间片大小，对于新到达的进程，首先放入优先级最高的队列中，如果进程执行时间过长，会被移动到优先级较低的队列中，以此类推。

以上是常见的进程调度算法，不同的算法适用于不同的场景，需要根据具体的应用场景选择合适的算法。

相关问题

进程调度算法c++我要五种

以下是五种进程调度算法的 C++ 代码实现：

1. 先来先服务（FCFS）调度算法

#include <iostream>
#include <queue>

using namespace std;

struct Process {
    int pid;    // 进程ID
    int arrival_time;   // 到达时间
    int burst_time; // 执行时间
    int waiting_time;   // 等待时间
    int turnaround_time;    // 周转时间
};

void fcfs(vector<Process>& processes) {
    int n = processes.size();
    queue<Process> q;
    int current_time = 0;
    for (int i = 0; i < n; i++) {
        Process process = processes[i];
        if (current_time < process.arrival_time) {
            current_time = process.arrival_time;   // 当前时间更新为进程到达时间
        }
        process.waiting_time = current_time - process.arrival_time;
        process.turnaround_time = process.waiting_time + process.burst_time;
        current_time += process.burst_time; // 当前时间更新为进程执行结束时间
        q.push(process);
    }
    while (!q.empty()) {
        Process process = q.front();
        q.pop();
        cout << "PID: " << process.pid << ", Waiting Time: " << process.waiting_time << ", Turnaround Time: " << process.turnaround_time << endl;
    }
}

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

2. 最短作业优先（SJF）调度算法

#include <iostream>
#include <queue>

using namespace std;

struct Process {
    int pid;    // 进程ID
    int arrival_time;   // 到达时间
    int burst_time; // 执行时间
    int waiting_time;   // 等待时间
    int turnaround_time;    // 周转时间
};

struct CompareProcess {
    bool operator()(Process& p1, Process& p2) {
        return p1.burst_time > p2.burst_time;   // 按执行时间从小到大排序
    }
};

void sjf(vector<Process>& processes) {
    int n = processes.size();
    priority_queue<Process, vector<Process>, CompareProcess> q;
    int current_time = 0;
    int total_waiting_time = 0;
    int total_turnaround_time = 0;
    for (int i = 0; i < n; i++) {
        Process process = processes[i];
        if (current_time < process.arrival_time) {
            current_time = process.arrival_time;   // 当前时间更新为进程到达时间
        }
        process.waiting_time = current_time - process.arrival_time;
        total_waiting_time += process.waiting_time;
        process.turnaround_time = process.waiting_time + process.burst_time;
        total_turnaround_time += process.turnaround_time;
        current_time += process.burst_time; // 当前时间更新为进程执行结束时间
        q.push(process);
    }
    while (!q.empty()) {
        Process process = q.top();
        q.pop();
        cout << "PID: " << process.pid << ", Waiting Time: " << process.waiting_time << ", Turnaround Time: " << process.turnaround_time << endl;
    }
    cout << "Average Waiting Time: " << (double)total_waiting_time / n << endl;
    cout << "Average Turnaround Time: " << (double)total_turnaround_time / n << endl;
}

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

3. 最短剩余时间优先（SRTF）调度算法

#include <iostream>
#include <queue>

using namespace std;

struct Process {
    int pid;    // 进程ID
    int arrival_time;   // 到达时间
    int burst_time; // 执行时间
    int remaining_time; // 剩余执行时间
    int waiting_time;   // 等待时间
    int turnaround_time;    // 周转时间
};

struct CompareProcess {
    bool operator()(Process& p1, Process& p2) {
        return p1.remaining_time > p2.remaining_time; // 按剩余执行时间从小到大排序
    }
};

void srtf(vector<Process>& processes) {
    int n = processes.size();
    priority_queue<Process, vector<Process>, CompareProcess> q;
    int current_time = 0;
    int total_waiting_time = 0;
    int total_turnaround_time = 0;
    int completed_processes = 0;
    while (completed_processes < n) {
        for (int i = 0; i < n; i++) {
            Process& process = processes[i];
            if (process.arrival_time <= current_time && process.remaining_time > 0) {
                q.push(process);    // 将到达且未执行完的进程加入优先队列
            }
        }
        if (!q.empty()) {
            Process& process = q.top();
            q.pop();
            process.remaining_time--;
            if (process.remaining_time == 0) {
                completed_processes++;
                process.waiting_time = current_time - process.arrival_time - process.burst_time + 1;
                total_waiting_time += process.waiting_time;
                process.turnaround_time = process.waiting_time + process.burst_time;
                total_turnaround_time += process.turnaround_time;
            } else {
                q.push(process);    // 将未执行完的进程再次加入优先队列
            }
        }
        current_time++;
    }
    for (int i = 0; i < n; i++) {
        cout << "PID: " << processes[i].pid << ", Waiting Time: " << processes[i].waiting_time << ", Turnaround Time: " << processes[i].turnaround_time << endl;
    }
    cout << "Average Waiting Time: " << (double)total_waiting_time / n << endl;
    cout << "Average Turnaround Time: " << (double)total_turnaround_time / n << endl;
}

int main() {
    vector<Process> processes = {{1, 0, 10}, {2, 5, 4}, {3, 6, 2}, {4, 8, 6}};
    for (int i = 0; i < processes.size(); i++) {
        processes[i].remaining_time = processes[i].burst_time;  // 初始剩余执行时间等于执行时间
    }
    srtf(processes);
    return 0;
}

4. 时间片轮转（RR）调度算法

#include <iostream>
#include <queue>

using namespace std;

struct Process {
    int pid;    // 进程ID
    int arrival_time;   // 到达时间
    int burst_time; // 执行时间
    int remaining_time; // 剩余执行时间
    int waiting_time;   // 等待时间
    int turnaround_time;    // 周转时间
};

void rr(vector<Process>& processes, int quantum) {
    int n = processes.size();
    queue<Process> q;
    int current_time = 0;
    int total_waiting_time = 0;
    int total_turnaround_time = 0;
    int completed_processes = 0;
    while (completed_processes < n) {
        for (int i = 0; i < n; i++) {
            Process& process = processes[i];
            if (process.arrival_time <= current_time && process.remaining_time > 0) {
                q.push(process);    // 将到达且未执行完的进程加入队列
            }
        }
        if (!q.empty()) {
            Process process = q.front();
            q.pop();
            int execute_time = min(process.remaining_time, quantum);   // 执行时间为剩余执行时间和时间片长的较小值
            process.remaining_time -= execute_time;
            current_time += execute_time;   // 当前时间增加执行时间
            if (process.remaining_time == 0) {
                completed_processes++;
                process.waiting_time = current_time - process.arrival_time - process.burst_time;
                total_waiting_time += process.waiting_time;
                process.turnaround_time = process.waiting_time + process.burst_time;
                total_turnaround_time += process.turnaround_time;
            } else {
                q.push(process);    // 将未执行完的进程再次加入队列
            }
        } else {
            current_time++; // 如果队列为空，则时间增加1，等待下一个进程到达
        }
    }
    for (int i = 0; i < n; i++) {
        cout << "PID: " << processes[i].pid << ", Waiting Time: " << processes[i].waiting_time << ", Turnaround Time: " << processes[i].turnaround_time << endl;
    }
    cout << "Average Waiting Time: " << (double)total_waiting_time / n << endl;
    cout << "Average Turnaround Time: " << (double)total_turnaround_time / n << endl;
}

int main() {
    vector<Process> processes = {{1, 0, 10}, {2, 5, 4}, {3, 6, 2}, {4, 8, 6}};
    for (int i = 0; i < processes.size(); i++) {
        processes[i].remaining_time = processes[i].burst_time;  // 初始剩余执行时间等于执行时间
    }
    int quantum = 2;
    rr(processes, quantum);
    return 0;
}

5. 优先级调度算法

#include <iostream>
#include <queue>

using namespace std;

struct Process {
    int pid;    // 进程ID
    int arrival_time;   // 到达时间
    int burst_time; // 执行时间
    int priority;   // 优先级
    int waiting_time;   // 等待时间
    int turnaround_time;    // 周转时间
};

struct CompareProcess {
    bool operator()(Process& p1, Process& p2) {
        return p1.priority > p2.priority;   // 按优先级从小到大排序
    }
};

void priority(vector<Process>& processes) {
    int n = processes.size();
    priority_queue<Process, vector<Process>, CompareProcess> q;
    int current_time = 0;
    int total_waiting_time = 0;
    int total_turnaround_time = 0;
    int completed_processes = 0;
    while (completed_processes < n) {
        for (int i = 0; i < n; i++) {
            Process& process = processes[i];
            if (process.arrival_time <= current_time && process.burst_time > 0) {
                q.push(process);    // 将到达且未执行完的进程加入优先队列
            }
        }
        if (!q.empty()) {
            Process process = q.top();
            q.pop();
            process.burst_time--;
            current_time++; // 当前时间增加1
            if (process.burst_time == 0) {
                completed_processes++;
                process.waiting_time = current_time - process.arrival_time - process.turnaround_time;
                total_waiting_time += process.waiting_time;
                process.turnaround_time = current_time - process.arrival_time;
                total_turnaround_time += process.turnaround_time;
            } else {
                q.push(process);    // 将未执行完的进程再次加入优先队列
            }
        } else {
            current_time++; // 如果队列为空，则时间增加1，等待下一个进程到达
        }
    }
    for (int i = 0; i < n; i++) {
        cout << "PID: " << processes[i].pid << ", Waiting Time: " << processes[i].waiting_time << ", Turnaround Time: " << processes[i].turnaround_time << endl;
    }
    cout << "Average Waiting Time: " << (double)total_waiting_time / n << endl;
    cout << "Average Turnaround Time: " << (double)total_turnaround_time / n << endl;
}

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

进程调度算法C++

进程调度算法是操作系统中非常重要的一部分，用于决定哪些进程将被调度执行。常见的进程调度算法有以下几种：

1. 先来先服务（FCFS）调度算法：按照进程到达的先后顺序进行调度，先到达的进程先执行，后到达的进程后执行。

2. 最短作业优先（SJF）调度算法：按照进程的执行时间进行排序，执行时间短的进程先执行。

3. 优先级调度算法：为每个进程分配一个优先级，根据优先级高低进行调度。

4. 时间片轮转（RR）调度算法：将 CPU 时间分成多个时间片，每个进程执行一个时间片，时间片用完后将进程放到队列尾部，继续执行下一个进程。

下面是一个基于 FCFS 调度算法的 C++ 代码示例：

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

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

bool operator<(const Process &p1, const Process &p2) {
    return p1.arrive > p2.arrive;  // 按到达时间从小到大排序
}

int main() {
    priority_queue<Process> q;  // 优先队列，用于按到达时间排序
    int n;                      // 进程数
    cin >> n;
    for (int i = 0; i < n; i++) {
        Process p;
        cin >> p.pid >> p.arrive >> p.burst;
        q.push(p);
    }
    int time = 0;  // 当前时间
    while (!q.empty()) {
        Process p = q.top();
        q.pop();
        time = max(time, p.arrive);  // 更新时间，确保当前时间不小于进程的到达时间
        time += p.burst;             // 执行进程
        cout << p.pid << " " << time << endl;  // 输出进程 ID 和完成时间
    }
    return 0;
}