用c语言实现编程模拟实现进程调度算法 （FCFS与SPF算法，实现80分） （1）设计一个具有n（5≦n≦10）个并发进程的进程调度程序。每个进程用一个进程控制块（PCB）表示并作为管理的依据，采用结构体类型即可。进程控制块一般包含下列信息：进程名，进程到达时间、进程要求服务的时间，还需占用CPU的时间、进程优先级数以及进程的状态等。具体参数可以根据调度算法的不同进行增删，或者设计成一个通用的PCB。 （2）调度程序应包含两种不同的调度算法：FCFS和SPF调度算法。运行时，可由用户通过终端任选一种，以便进行各种算法的分析比较。 （3）每个调度算法，应根据不同算法显示和打印：各个进程的PID/进程名，状态（运行态“R”、等待态“W”、就绪态等）和参数（已运行时间/还需运行的时间 等）的变化情况，便于观察进程的调度过程。 （4）所有进程结束后，要打印输出各进程的执行次序，各进程的完成时间，各进程的周转时间及带权周转时间等参数指标，最后计算平均周转时间和平均带权周转时间。

以下是基于C语言实现的FCFS和SPF进程调度算法：

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

// 进程状态定义
#define READY 0
#define RUNNING 1
#define WAITING 2
#define FINISHED 3

// 进程控制块
typedef struct pcb {
    int pid; // 进程ID
    char name[10]; // 进程名
    int arrive_time; // 到达时间
    int service_time; // 服务时间
    int need_time; // 剩余需要服务时间
    int priority; // 优先级
    int status; // 进程状态
    int start_time; // 开始服务时间
    int finish_time; // 完成服务时间
} PCB;

// 初始化进程控制块数组
void init_pcb(PCB pcb[], int n) {
    for (int i = 0; i < n; i++) {
        pcb[i].pid = i + 1;
        sprintf(pcb[i].name, "P%d", i + 1);
        pcb[i].arrive_time = rand() % 10;
        pcb[i].service_time = rand() % 10 + 1;
        pcb[i].need_time = pcb[i].service_time;
        pcb[i].priority = rand() % 5 + 1;
        pcb[i].status = READY;
        pcb[i].start_time = -1;
        pcb[i].finish_time = -1;
    }
}

// 输出进程控制块信息
void print_pcb(PCB pcb[], int n) {
    printf("PID\tName\tArrive\tService\tNeed\tPriority\tStatus\n");
    for (int i = 0; i < n; i++) {
        printf("%d\t%s\t%d\t%d\t%d\t%d\t", pcb[i].pid, pcb[i].name,
               pcb[i].arrive_time, pcb[i].service_time, pcb[i].need_time,
               pcb[i].priority);
        switch (pcb[i].status) {
            case READY:
                printf("Ready\n");
                break;
            case RUNNING:
                printf("Running\n");
                break;
            case WAITING:
                printf("Waiting\n");
                break;
            case FINISHED:
                printf("Finished\n");
                break;
        }
    }
}

// FCFS调度算法
void fcfs(PCB pcb[], int n) {
    int time = 0;
    int index = 0;
    int finished = 0;

    printf("FCFS Scheduling:\n");

    while (finished < n) {
        // 找到最早到达的进程
        int min_arrive_time = -1;
        for (int i = 0; i < n; i++) {
            if (pcb[i].status != FINISHED &&
                    (min_arrive_time == -1 || pcb[i].arrive_time < min_arrive_time)) {
                min_arrive_time = pcb[i].arrive_time;
                index = i;
            }
        }

        // 将进程从就绪态变为运行态
        pcb[index].status = RUNNING;
        pcb[index].start_time = time;

        printf("Time: %d, Process %s running\n", time, pcb[index].name);

        // 运行进程
        pcb[index].need_time--;
        time++;

        if (pcb[index].need_time == 0) {
            // 进程完成
            pcb[index].status = FINISHED;
            pcb[index].finish_time = time;

            printf("Time: %d, Process %s finished\n", time, pcb[index].name);

            finished++;
        }
    }

    printf("Process execution order: ");
    for (int i = 0; i < n; i++) {
        printf("%s ", pcb[i].name);
    }
    printf("\n");

    int total_turnaround_time = 0;
    int total_weighted_turnaround_time = 0;
    for (int i = 0; i < n; i++) {
        int turnaround_time = pcb[i].finish_time - pcb[i].arrive_time;
        int weighted_turnaround_time = turnaround_time / pcb[i].service_time;
        total_turnaround_time += turnaround_time;
        total_weighted_turnaround_time += weighted_turnaround_time;

        printf("Process %s: turnaround time=%d, weighted turnaround time=%d\n",
               pcb[i].name, turnaround_time, weighted_turnaround_time);
    }
    printf("Average turnaround time=%.2f, average weighted turnaround time=%.2f\n",
           (float) total_turnaround_time / n, (float) total_weighted_turnaround_time / n);
}

// SPF调度算法
void spf(PCB pcb[], int n) {
    int time = 0;
    int index = 0;
    int finished = 0;

    printf("SPF Scheduling:\n");

    while (finished < n) {
        // 找到最短剩余服务时间的进程
        int min_need_time = -1;
        for (int i = 0; i < n; i++) {
            if (pcb[i].status != FINISHED &&
                    (min_need_time == -1 || pcb[i].need_time < min_need_time)) {
                min_need_time = pcb[i].need_time;
                index = i;
            }
        }

        // 将进程从就绪态变为运行态
        pcb[index].status = RUNNING;
        pcb[index].start_time = time;

        printf("Time: %d, Process %s running\n", time, pcb[index].name);

        // 运行进程
        pcb[index].need_time--;
        time++;

        if (pcb[index].need_time == 0) {
            // 进程完成
            pcb[index].status = FINISHED;
            pcb[index].finish_time = time;

            printf("Time: %d, Process %s finished\n", time, pcb[index].name);

            finished++;
        }
    }

    printf("Process execution order: ");
    for (int i = 0; i < n; i++) {
        printf("%s ", pcb[i].name);
    }
    printf("\n");

    int total_turnaround_time = 0;
    int total_weighted_turnaround_time = 0;
    for (int i = 0; i < n; i++) {
        int turnaround_time = pcb[i].finish_time - pcb[i].arrive_time;
        int weighted_turnaround_time = turnaround_time / pcb[i].service_time;
        total_turnaround_time += turnaround_time;
        total_weighted_turnaround_time += weighted_turnaround_time;

        printf("Process %s: turnaround time=%d, weighted turnaround time=%d\n",
               pcb[i].name, turnaround_time, weighted_turnaround_time);
    }
    printf("Average turnaround time=%.2f, average weighted turnaround time=%.2f\n",
           (float) total_turnaround_time / n, (float) total_weighted_turnaround_time / n);
}

int main() {
    srand(time(NULL));

    int n = rand() % 6 + 5; // 进程数在5~10之间随机生成

    PCB pcb[n];
    init_pcb(pcb, n);
    print_pcb(pcb, n);

    fcfs(pcb, n);
    spf(pcb, n);

    return 0;
}

这个程序使用了结构体类型来表示进程控制块，并且实现了FCFS和SPF两种进程调度算法。程序随机生成5~10个进程，每个进程都有一个进程名、到达时间、服务时间、优先级和状态等信息。程序输出各个进程的信息，并且通过FCFS和SPF两种算法进行进程调度，输出进程的执行顺序、完成时间、周转时间和带权周转时间等参数指标。

注意：这个程序只是一个基本的模拟程序，实际的进程调度算法要比这个复杂得多。