抢占式静态优先级调度算法代码实现

抢占式静态优先级调度算法是一种用于实时系统中的任务调度策略，它预先给每个任务分配一个固定的优先级，当有更高优先级的任务就绪时，会立即抢占当前运行的任务并切换到高优先级任务。这里是一个简单的基于优先级队列的C语言伪代码实现：

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

// 定义任务结构体
typedef struct Task {
    int pid;       // 进程ID
    int priority;  // 优先级
    void (*function)(void*);   // 函数指针
    void* arg;     // 参数
} Task;

// 比较函数，用于优先级队列
int compareTasks(const void* a, const void* b) {
    return ((Task*)a)->priority - ((Task*)b)->priority;
}

// 调度函数
void schedule(Task* tasks, int num_tasks) {
    if (tasks == NULL || num_tasks <= 0)
        return;

    // 创建优先级队列
    Task** pq = malloc(sizeof(Task*) * num_tasks);
    for (int i = 0; i < num_tasks; i++) {
        pq[i] = &tasks[i];
    }
    qsort(pq, num_tasks, sizeof(Task*), compareTasks);

    while (pq[0] != NULL) {
        // 执行最高优先级的任务
        (*pq[0])->function(pq[0]->arg);
        
        // 如果该任务完成，从队列中移除
        free(pq[0]);
        pq[0] = pq++;
        if (pq >= pq + num_tasks)
            break;
    }

    free(pq);
}

// 示例任务定义
void taskA(void* arg) { ... }
void taskB(void* arg) { ... }
...

int main() {
    Task tasks[] = {
        {1, 5, taskA, NULL},
        {2, 10, taskB, NULL}
    };
    schedule(tasks, sizeof(tasks) / sizeof(tasks[0]));
    return 0;
}