生成一段抢占式优先级调度算法的C语言代码

好的，下面是一段简单的抢占式优先级调度算法的 C 代码，实现了基本的进程调度功能。

#include <stdio.h>
#include <stdlib.h>

// 进程结构体
typedef struct {
    int pid;              // 进程 ID
    int priority;         // 进程优先级
    int remaining_time;   // 剩余时间片
} Process;

// 定义一个比较器，用于将优先级最高的进程排在队列前面
int compare_process(const void* a, const void* b) {
    Process* p1 = (Process*)a;
    Process* p2 = (Process*)b;
    return p2->priority - p1->priority;
}

int main() {
    // 创建一些进程，并加入到数组中
    Process processes[3];
    processes[0].pid = 1;
    processes[0].priority = 10;
    processes[0].remaining_time = 20;
    processes[1].pid = 2;
    processes[1].priority = 5;
    processes[1].remaining_time = 30;
    processes[2].pid = 3;
    processes[2].priority = 8;
    processes[2].remaining_time = 25;

    // 执行进程调度，将优先级最高的进程取出并运行
    int current_time = 0;
    while (1) {
        // 检查是否所有进程都已经完成
        int all_finished = 1;
        for (int i = 0; i < 3; i++) {
            if (processes[i].remaining_time > 0) {
                all_finished = 0;
                break;
            }
        }
        if (all_finished) {
            break;
        }

        // 找到优先级最高的进程
        int highest_priority = -1;
        int highest_priority_index = -1;
        for (int i = 0; i < 3; i++) {
            if (processes[i].remaining_time > 0 && processes[i].priority > highest_priority) {
                highest_priority = processes[i].priority;
                highest_priority_index = i;
            }
        }
        if (highest_priority_index == -1) {
            // 没有找到可执行的进程，继续下一次循环
            current_time++;
            continue;
        }

        // 运行进程
        Process* current_process = &processes[highest_priority_index];
        printf("Time %d: Running process %d (priority %d, remaining time %d)\n",
               current_time, current_process->pid, current_process->priority, current_process->remaining_time);
        current_process->remaining_time--;
        current_time++;

        // 如果进程还有剩余时间片，重新加入到数组中
        if (current_process->remaining_time > 0) {
            qsort(processes, 3, sizeof(Process), compare_process);
        }
    }

    return 0;
}

以上代码实现了一个简单的抢占式优先级调度算法，每次选择优先级最高的进程进行调度，并按照优先级重新排序数组。注意，在实际应用中，我们可能需要考虑更复杂的场景和算法实现。