C语言实现时间片轮转算法

时间片轮转算法是一种常见的调度算法，它将 CPU 的使用时间划分成若干个时间片，每个进程在时间片内执行一定的时间，然后将 CPU 释放给其他进程，以此来实现多道程序并发执行。下面是一个简单的 C 语言实现示例：

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

// 进程结构体
typedef struct process {
    int pid;         // 进程 ID
    int priority;    // 进程优先级
    int burst_time;  // 进程需要执行的时间
    int remaining_time;  // 剩余执行时间
    int waiting_time;    // 等待时间
    int turnaround_time; // 周转时间
} Process;

// 时间片轮转调度算法
void round_robin(Process *processes, int n, int quantum) {
    int i, j, time = 0, done = 0;
    double avg_waiting_time = 0, avg_turnaround_time = 0;

    // 初始化进程的剩余执行时间
    for (i = 0; i < n; i++) {
        processes[i].remaining_time = processes[i].burst_time;
    }

    // 轮流执行每个进程
    while (done < n) {
        for (i = 0; i < n; i++) {
            if (processes[i].remaining_time > 0) {
                if (processes[i].remaining_time > quantum) {
                    time += quantum;
                    processes[i].remaining_time -= quantum;
                } else {
                    time += processes[i].remaining_time;
                    processes[i].waiting_time = time - processes[i].burst_time;
                    processes[i].remaining_time = 0;
                    processes[i].turnaround_time = time;
                    avg_waiting_time += processes[i].waiting_time;
                    avg_turnaround_time += processes[i].turnaround_time;
                    done++;
                }
            }
        }
    }

    // 计算平均等待时间和平均周转时间
    avg_waiting_time /= n;
    avg_turnaround_time /= n;

    // 输出结果
    printf("PID\tPriority\tBurst Time\tWaiting Time\tTurnaround Time\n");
    for (i = 0; i < n; i++) {
        printf("%d\t%d\t\t%d\t\t%d\t\t%d\n", processes[i].pid, processes[i].priority, processes[i].burst_time, processes[i].waiting_time, processes[i].turnaround_time);
    }
    printf("Average Waiting Time: %.2lf\n", avg_waiting_time);
    printf("Average Turnaround Time: %.2lf\n", avg_turnaround_time);
}

int main() {
    int n, quantum, i;
    Process *processes;

    // 读取进程数量和时间片大小
    printf("Enter the number of processes: ");
    scanf("%d", &n);
    printf("Enter the time quantum: ");
    scanf("%d", &quantum);

    // 动态分配进程结构体数组
    processes = (Process*)malloc(n * sizeof(Process));

    // 读取每个进程的信息
    for (i = 0; i < n; i++) {
        printf("Enter the priority and burst time for process %d: ", i + 1);
        scanf("%d %d", &processes[i].priority, &processes[i].burst_time);
        processes[i].pid = i + 1;
    }

    // 执行时间片轮转调度算法
    round_robin(processes, n, quantum);

    // 释放内存
    free(processes);

    return 0;
}

在这个示例程序中，我们首先定义了一个 `Process` 结构体，用来表示进程的各种属性，包括进程 ID、优先级、需要执行的时间、剩余执行时间、等待时间和周转时间。然后，我们定义了一个 `round_robin` 函数，用来实现时间片轮转算法。该函数接受一个进程结构体数组、进程数量和时间片大小作为参数，并且在执行完毕后计算平均等待时间和平均周转时间，并输出每个进程的信息以及整体的平均结果。最后，我们在 `main` 函数中读取进程数量和时间片大小，动态分配进程结构体数组，读取每个进程的信息，然后调用 `round_robin` 函数执行时间片轮转算法，并释放内存。