操作系统短作业优先算法含时间片段代码

短作业优先算法是一种非常常用的作业调度算法，用于提高系统的吞吐量和响应时间。它将估计执行时间最短的作业放在最前面，优先执行。下面是一个简单的短作业优先算法的代码实现（含时间片段）：

// 进程结构体
typedef struct PCB {
    int pid;                // 进程 ID
    int burst_time;         // 进程估计执行时间
    int remaining_time;     // 进程剩余执行时间
    int arrival_time;       // 进程到达时间
    int finish_time;        // 进程完成时间
    int turnaround_time;    // 进程周转时间
    int waiting_time;       // 进程等待时间
    int priority;           // 进程优先级
} PCB;

// 短作业优先算法函数
void SJF(PCB processes[], int n) {
    int total_time = 0;
    int total_waiting_time = 0;
    int total_turnaround_time = 0;

    // 将进程按照到达时间排序
    sort(processes, processes + n, [](PCB a, PCB b) {
        return a.arrival_time < b.arrival_time;
    });

    // 初始时将第一个进程放入就绪队列
    vector<PCB> ready_queue;
    ready_queue.push_back(processes[0]);

    // 当前正在执行的进程
    PCB running_process = ready_queue[0];
    running_process.remaining_time--;

    // 短作业优先算法的核心部分
    while (!ready_queue.empty()) {
        // 将剩余时间为 0 的进程移出就绪队列
        for (int i = 0; i < ready_queue.size(); i++) {
            if (ready_queue[i].remaining_time == 0) {
                ready_queue[i].finish_time = total_time;
                ready_queue[i].turnaround_time = ready_queue[i].finish_time - ready_queue[i].arrival_time;
                ready_queue[i].waiting_time = ready_queue[i].turnaround_time - ready_queue[i].burst_time;
                total_waiting_time += ready_queue[i].waiting_time;
                total_turnaround_time += ready_queue[i].turnaround_time;
                ready_queue.erase(ready_queue.begin() + i);
                i--;
            }
        }

        // 将到达时间不晚于当前时间的进程加入就绪队列
        for (int i = 1; i < n; i++) {
            if (processes[i].arrival_time <= total_time && processes[i].remaining_time > 0) {
                ready_queue.push_back(processes[i]);
            }
        }

        // 如果就绪队列为空，说明没有进程在等待执行，等待下一个进程到达
        if (ready_queue.empty()) {
            total_time++;
            continue;
        }

        // 选择剩余时间最短的进程执行
        int shortest_index = 0;
        for (int i = 1; i < ready_queue.size(); i++) {
            if (ready_queue[i].remaining_time < ready_queue[shortest_index].remaining_time) {
                shortest_index = i;
            }
        }

        // 如果当前正在执行的进程和就绪队列中最短的进程不同，说明发生了抢占
        if (running_process.pid != ready_queue[shortest_index].pid) {
            running_process.priority++;
            ready_queue[shortest_index].priority--;
            running_process = ready_queue[shortest_index];
        }

        // 执行当前进程
        running_process.remaining_time--;
        total_time++;

        // 如果当前进程的时间片段已经用完，重新加入就绪队列
        if (running_process.remaining_time == 0) {
            running_process.finish_time = total_time;
            running_process.turnaround_time = running_process.finish_time - running_process.arrival_time;
            running_process.waiting_time = running_process.turnaround_time - running_process.burst_time;
            total_waiting_time += running_process.waiting_time;
            total_turnaround_time += running_process.turnaround_time;

            // 从就绪队列中删除当前进程
            for (int i = 0; i < ready_queue.size(); i++) {
                if (ready_queue[i].pid == running_process.pid) {
                    ready_queue.erase(ready_queue.begin() + i);
                    break;
                }
            }

            // 将剩余时间不为 0 的进程加入就绪队列
            for (int i = 1; i < n; i++) {
                if (processes[i].arrival_time <= total_time && processes[i].remaining_time > 0) {
                    ready_queue.push_back(processes[i]);
                }
            }

            // 选择剩余时间最短的进程执行
            shortest_index = 0;
            for (int i = 1; i < ready_queue.size(); i++) {
                if (ready_queue[i].remaining_time < ready_queue[shortest_index].remaining_time) {
                    shortest_index = i;
                }
            }

            running_process = ready_queue[shortest_index];
        }
    }

    // 输出结果
    printf("Average waiting time: %.2f\n", (float)total_waiting_time / n);
    printf("Average turnaround time: %.2f\n", (float)total_turnaround_time / n);
}

在上述代码中，我们使用了一个 `PCB` 结构体来表示进程的相关信息。在算法实现中，我们首先将进程按照到达时间排序，然后将第一个进程放入就绪队列中。在每个时间片段中，我们将剩余时间为 0 的进程移出就绪队列，将到达时间不晚于当前时间的进程加入就绪队列。然后选择剩余时间最短的进程执行，如果发生了抢占，需要重新调整各个进程的优先级。当当前进程的时间片段用完后，我们需要将它重新加入就绪队列，并选择剩余时间最短的进程执行。最后，我们计算出所有进程的平均等待时间和平均周转时间，并输出结果。