SJF抢占式C语言代码

引自免费微信小程序：皆我百晓生

为了实现短作业优先（SJF）抢占式调度算法，你需要首先对进程按服务时间进行排序，然后在每个时刻检查是否有新到达的进程，并根据当前运行进程的服务时间是否结束来决定是否进行抢占。下面是完整的C语言代码实现：

#include 
#include 

typedef struct Process {
    int id;
    int arrival_time; // 到达时间
    int burst_time;   // 服务时间
    int wait_time;    // 等待时间
    int start_time;   // 开始时间
    int finish_time;  // 完成时间
    int turnaround_time; // 周转时间
} Process;

int compare(const void *a, const void *b) {
    Process *processA = (Process *)a;
    Process *processB = (Process *)b;
    return processA->burst_time - processB->burst_time;
}

// 函数用于更新进程状态并返回下一个开始执行的进程ID
int update_processes(Process processes[], int n, int current_time) {
    int next_process_id = -1;
    for (int i = 0; i < n; i++) {
        if (processes[i].arrival_time <= current_time && processes[i].start_time == 0) {
            processes[i].start_time = current_time;
            processes[i].wait_time = current_time - processes[i].arrival_time;
            next_process_id = i;
            break;
        } else if (next_process_id == -1 && processes[i].start_time > 0 && processes[i].burst_time > 0) {
            processes[i].burst_time -= 1;
            if (processes[i].burst_time == 0) {
                processes[i].finish_time = current_time + 1;
                processes[i].turnaround_time = processes[i].finish_time - processes[i].arrival_time;
                next_process_id = i;
            }
        }
    }
    return next_process_id;
}

void SJF_preemptive1(int n) {
    Process processes[] = {
        {1, 0, 4, 0, 0, 0, 0},
        {2, 2, 6, 0, 0, 0, 0},
        {3, 6, 1, 0, 0, 0, 0},
        {4, 8, 3, 0, 0, 0, 0},
        {5, 10, 2, 0, 0, 0, 0}
    };

    // 对进程按服务时间进行排序
    qsort(processes, n, sizeof(Process), compare);

    int current_time = 0;
    while (true) {
        int next_process_id = update_processes(processes, n, current_time);
        if (next_process_id == -1) break; // 所有进程完成

        current_time++;
    }

    // 输出结果
    for (int i = 0; i < n; i++) {
        printf("Process %d: Arrival=%d, Burst=%d, Start=%d, Finish=%d, Wait=%d, Turnaround=%d\n",
               processes[i].id,
               processes[i].arrival_time,
               processes[i].burst_time,
               processes[i].start_time,
               processes[i].finish_time,
               processes[i].wait_time,
               processes[i].turnaround_time);
    }
}

int main() {
    SJF_preemptive1(5);
    return 0;
}

这段代码首先定义了一个update_processes函数，它遍历所有进程，找到最早到达且未开始的进程，设置其开始时间并计算等待时间。如果有进程正在执行并且其服务时间减少到0，则更新其完成时间、周转时间和剩余进程列表。当所有进程都已完成时，循环终止。

在SJF_preemptive1函数中，我们首先对进程数组进行排序，然后在一个无限循环中调用update_processes函数，直到所有进程完成。最后，输出所有进程的状态信息。

将这个代码复制到一个名为sjf_preemptive.c的文件中，然后编译和运行它，你会得到每个进程的详细信息。例如：

gcc sjf_preemptive.c -o sjf_preemptive
./sjf_preemptive

这将输出每个进程的ID、到达时间、服务时间、开始时间、完成时间、等待时间和周转时间。