个人技术分享

#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdlib>
#define maxn 10;

using namespace std;

// 进程控制块（PCB）
struct Process {
    int name;//进程标识符
    int status;//进程状态
    int pri;//进程优先数
    int time;//剩余运行时间，以时间片为单位，当减至0时该进程终止
};

// 时间片轮转调度算法
void roundRobin(vector<Process> processes, int quantum) {
    cout << "时间片轮转调度算法" << endl;
    int n = processes.size();
    int current_time = 0;
    int current_process = 0;

    while (true) {
        if (processes[current_process].status == 1) {
            cout << "进程 " << processes[current_process].name << " 正在运行" << endl;
            processes[current_process].time -= min(quantum, processes[current_process].time);
            current_time += min(quantum, processes[current_process].time);

        }

        if(processes[current_process].time <= 0){//调整进程状态
            processes[current_process].status = 0;
        }

        current_process = (current_process + 1) % n;//指向下一个进程

        bool all_finished = true;
        for (int i = 0; i < n; ++i) {//判断进程是否执行完毕
            if (processes[i].status > 0) {
                all_finished = false;
                break;
            }
        }

        if (all_finished) break;//所有进程执行完毕，终止
    }
}

// 优先数调度算法
void priorityScheduling(vector<Process> processes) {
    cout << "优先数调度算法" << endl;
    int n = processes.size();
    sort(processes.begin(), processes.end(), [](const Process& a, const Process& b) {
        return a.pri > b.pri;
    });//将进程队列按照优先数进行排序

    for (int i = 0; i < n; ++i) {
        cout << "进程 " << processes[i].name << " 正在运行" << endl;
    }
}

// 最短进程优先调度算法
void shortestJobFirst(vector<Process> processes) {
    cout << "最短进程优先调度算法" << endl;
    int n = processes.size();
    sort(processes.begin(), processes.end(), [](const Process& a, const Process& b) {
        return a.time < b.time;
    });//将进程队列按照需要时间进行排序

    for (int i = 0; i < n; ++i) {
        processes[i].status=0;
        cout << "进程 " << processes[i].name << " 正在运行" << endl;
    }
}

// 最短剩余时间优先调度算法
void shortestRemainingTimeFirst(vector<Process> processes) {
    cout << "最短剩余时间优先调度算法" << endl;
    int n = processes.size();

    while (true) {
        sort(processes.begin(), processes.end(), [](const Process& a, const Process& b) {
            return a.time < b.time;
        });//每次运行完一次进程都排序一次，把剩余时间最少的放在第一个

        int next_process = -1;
        for (int i = 0; i < n; ++i) {//遍历所进程，判断是否全部执行完毕
            if (processes[i].time > 0) {
                next_process = i;
                break;
            }else{
                processes[i].status=0;
            }
        }

        if (next_process == -1) break;

        cout << "进程 " << processes[next_process].name << " 正在运行" << endl;
        processes[next_process].time -= 1;
    }
}

//创建进程
void creatpcb(vector<Process>& pcb,vector<int>& hash){
    srand(time(nullptr));//设置随机数种子为当前时间

    int n=maxn;//进程数量

    while(n){
        int random_number = rand()%100;//生成随机数
        Process p;

        if(hash[random_number]==0){
            p.name=random_number;
            p.time=random_number%10;
            p.pri=random_number%7;
            p.status=1;
            --n;
            pcb.push_back(p);
            cout << "生成进程: " << p.name << " 需要时间: " << p.time << " 优先数:" << p.pri << " 状态(1为就绪态,0为终止): " << p.status << endl;
        }
    }

}

int main() {
    int m=100;
    vector<int> hash(m,0);

    vector<Process> processes;//模拟进程就绪队列

    creatpcb(processes,hash);//创建进程
    cout << endl;

    roundRobin(processes, 3);//时间片轮转
    cout << endl;

    priorityScheduling(processes);//优先数调度
    cout << endl;

    shortestJobFirst(processes);//最短进程优先
    cout << endl;

    shortestRemainingTimeFirst(processes);//最短剩余时间

    char ch=getchar();//按任意键结束
    return 0;
}