C语言实现简单的作业调度系统

好的，我可以为您提供一个简单的C语言实现作业调度系统的代码示例，供您参考：

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

#define MAX_PROCESS 10

/* 进程控制块 */
typedef struct process_control_block {
    int pid;            // 进程ID
    int arrival_time;   // 到达时间
    int burst_time;     // 执行时间
    int priority;       // 优先级
    int status;         // 进程状态（0-未运行，1-运行，2-完成）
} PCB;

/* 进程队列 */
typedef struct process_queue {
    PCB *pcb[MAX_PROCESS];  // 进程控制块指针数组
    int front, rear;        // 队列头和尾指针
} Queue;

/* 初始化进程队列 */
void init_queue(Queue *q) {
    q->front = q->rear = 0;
}

/* 判断队列是否为空 */
int is_queue_empty(Queue *q) {
    return (q->front == q->rear);
}

/* 判断队列是否已满 */
int is_queue_full(Queue *q) {
    return ((q->rear + 1) % MAX_PROCESS == q->front);
}

/* 入队 */
void enqueue(Queue *q, PCB *pcb) {
    if (is_queue_full(q)) {
        printf("队列已满，无法入队！\n");
        exit(1);
    }
    q->pcb[q->rear] = pcb;
    q->rear = (q->rear + 1) % MAX_PROCESS;
}

/* 出队 */
PCB *dequeue(Queue *q) {
    if (is_queue_empty(q)) {
        printf("队列已空，无法出队！\n");
        exit(1);
    }
    PCB *pcb = q->pcb[q->front];
    q->front = (q->front + 1) % MAX_PROCESS;
    return pcb;
}

/* 打印进程信息 */
void print_pcb(PCB *pcb) {
    printf("进程ID：%d 到达时间：%d 执行时间：%d 优先级：%d\n",
        pcb->pid, pcb->arrival_time, pcb->burst_time, pcb->priority);
}

/* 先来先服务算法 */
void fcfs(PCB *pcb[], int n) {
    printf("== 先来先服务算法 ==\n");
    int i, current_time = 0, total_waiting_time = 0;
    for (i = 0; i < n; i++) {
        if (current_time < pcb[i]->arrival_time) {
            current_time = pcb[i]->arrival_time;
        }
        current_time += pcb[i]->burst_time;
        pcb[i]->status = 2; // 进程完成
        pcb[i]->priority = -1; // 优先级无用
        pcb[i]->waiting_time = current_time - pcb[i]->arrival_time - pcb[i]->burst_time;
        total_waiting_time += pcb[i]->waiting_time;
    }
    printf("平均等待时间：%f\n", (float) total_waiting_time / n);
}

/* 最短作业优先算法 */
void sjf(PCB *pcb[], int n) {
    printf("== 最短作业优先算法 ==\n");
    int i, j, current_time = 0, total_waiting_time = 0;
    Queue q;
    init_queue(&q);
    for (i = 0; i < n; i++) {
        if (current_time < pcb[i]->arrival_time) { // 还未到达
            current_time = pcb[i]->arrival_time;
        }
        for (j = i + 1; j < n; j++) { // 将所有到达时间小于等于当前时间的进程入队
            if (pcb[j]->arrival_time <= current_time) {
                enqueue(&q, pcb[j]);
            }
        }
        enqueue(&q, pcb[i]); // 将当前进程入队
        if (is_queue_empty(&q)) { // 队列已空，说明当前进程是最后一个到达的进程
            pcb[i]->status = 2; // 进程完成
            pcb[i]->priority = -1; // 优先级无用
            pcb[i]->waiting_time = 0;
            total_waiting_time += pcb[i]->waiting_time;
        } else { // 队列非空，执行队首进程
            PCB *p = dequeue(&q);
            current_time += p->burst_time;
            p->status = 2; // 进程完成
            p->priority = -1; // 优先级无用
            p->waiting_time = current_time - p->arrival_time - p->burst_time;
            total_waiting_time += p->waiting_time;
            for (j = i + 1; j < n; j++) { // 将队列中所有到达时间小于等于当前时间的进程入队
                if (pcb[j]->arrival_time <= current_time) {
                    enqueue(&q, pcb[j]);
                }
            }
        }
    }
    printf("平均等待时间：%f\n", (float) total_waiting_time / n);
}

int main() {
    PCB *pcb[MAX_PROCESS] = {
        &(PCB){1, 0, 10, 0, 0},
        &(PCB){2, 1, 5, 0, 0},
        &(PCB){3, 2, 8, 0, 0},
        &(PCB){4, 3, 3, 0, 0},
        &(PCB){5, 4, 12, 0, 0}
    };
    int i, n = 5;
    for (i = 0; i < n; i++) {
        print_pcb(pcb[i]);
    }
    fcfs(pcb, n);
    sjf(pcb, n);
    return 0;
}

以上是一个简单的作业调度系统实现示例，其中包括了先来先服务算法和最短作业优先算法。您可以根据需要进行修改和扩展，以实现更加复杂的调度算法。同时需要注意，该示例仅用于参考，实际应用中需要进行充分的测试和调试，以保证系统的稳定性和正确性。