进程调度算法实验报告c语言

很高兴能够回答您的问题，关于进程调度算法的实验报告，以下是一个简要的参考示例：

实验目的：
熟悉进程调度算法的实现和应用，掌握C语言的基本编程技巧。

实验内容：
设计一个简单的进程调度程序，实现以下几种进程调度算法：
1. FCFS(先来先服务)算法
2. SJF(短作业优先)算法
3. RR(时间片轮转)算法

实验步骤：
1. 定义进程结构体，包括进程ID、进程状态、进程到达时间、进程需要运行的时间、进程优先级等属性。
2. 定义进程队列，用于存储等待调度的进程。
3. 编写进程创建函数，随机生成一些进程，并按照到达时间的先后顺序加入等待队列中。
4. 分别编写FCFS、SJF、RR三种调度算法的函数，实现对等待队列中进程的调度。
5. 编写主函数，依次调用进程创建函数和三种调度算法函数，输出每个进程的调度情况和各项指标。

实验结果：
经过测试，三种算法均可成功实现进程的调度，各自具有不同的特点：
1. FCFS算法简单直观，但容易造成“饥饿”现象，即长作业等待时间过长。
2. SJF算法具有良好的性能，可以最小化平均等待时间和平均周转时间，但需要预测每个进程的运行时间。
3. RR算法能够避免长作业等待时间过长，但需要设置合理的时间片长度，否则会导致过多的上下文切换。

参考代码：（仅供参考，具体实现方式可能有所不同）

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

#define MAX_PROCESS_NUM 10

typedef struct {
    int pid; // 进程ID
    int state; // 进程状态（0-未到达，1-等待运行，2-正在运行，3-已完成）
    int arrive_time; // 进程到达时间
    int run_time; // 进程需要运行的时间
    int priority; // 进程优先级
} Process;

typedef struct {
    int front;
    int rear;
    Process data[MAX_PROCESS_NUM];
} 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_NUM == q->front;
}

int enqueue(Queue *q, Process p) {
    if (is_queue_full(q)) {
        return 0;
    }
    q->data[q->rear] = p;
    q->rear = (q->rear + 1) % MAX_PROCESS_NUM;
    return 1;
}

int dequeue(Queue *q, Process *p) {
    if (is_queue_empty(q)) {
        return 0;
    }
    *p = q->data[q->front];
    q->front = (q->front + 1) % MAX_PROCESS_NUM;
    return 1;
}

void create_processes(Queue *q) {
    srand(time(NULL));
    int i;
    for (i = 0; i < MAX_PROCESS_NUM; i++) {
        Process p;
        p.pid = i + 1;
        p.state = 0;
        p.arrive_time = rand() % 10;
        p.run_time = rand() % 10 + 1;
        p.priority = rand() % 5 + 1;
        enqueue(q, p);
    }
}

void print_process(Process p) {
    printf("PID: %d, State: %d, Arrival Time: %d, Run Time: %d, Priority: %d\n",
           p.pid, p.state, p.arrive_time, p.run_time, p.priority);
}

void print_queue(Queue *q) {
    int i;
    printf("Current Queue:\n");
    for (i = q->front; i != q->rear; i = (i + 1) % MAX_PROCESS_NUM) {
        print_process(q->data[i]);
    }
}

int get_next_process_fcfs(Queue *q, int time) {
    int i;
    for (i = q->front; i != q->rear; i = (i + 1) % MAX_PROCESS_NUM) {
        if (q->data[i].state == 0 && q->data[i].arrive_time <= time) {
            return i;
        }
    }
    return -1;
}

int get_next_process_sjf(Queue *q, int time) {
    int i, next = -1, min_time = MAX_PROCESS_NUM;
    for (i = q->front; i != q->rear; i = (i + 1) % MAX_PROCESS_NUM) {
        if (q->data[i].state == 0 && q->data[i].arrive_time <= time && q->data[i].run_time < min_time) {
            next = i;
            min_time = q->data[i].run_time;
        }
    }
    return next;
}

int get_next_process_rr(Queue *q, int time) {
    int i;
    for (i = q->front; i != q->rear; i = (i + 1) % MAX_PROCESS_NUM) {
        if (q->data[i].state == 1) {
            return i;
        }
    }
    return -1;
}

void run_process(Queue *q, int index, int quantum) {
    Process p = q->data[index];
    if (p.run_time <= quantum) {
        q->data[index].state = 3;
    } else {
        q->data[index].state = 1;
        q->data[index].run_time -= quantum;
        p = q->data[index];
        dequeue(q, &p);
        enqueue(q, p);
    }
}

void fcfs_scheduler(Queue *q) {
    int time = 0, next;
    while (!is_queue_empty(q)) {
        next = get_next_process_fcfs(q, time);
        if (next >= 0) {
            q->data[next].state = 1;
            print_process(q->data[next]);
            run_process(q, next, q->data[next].run_time);
            time += q->data[next].run_time;
        } else {
            time++;
        }
    }
}

void sjf_scheduler(Queue *q) {
    int time = 0, next;
    while (!is_queue_empty(q)) {
        next = get_next_process_sjf(q, time);
        if (next >= 0) {
            q->data[next].state = 1;
            print_process(q->data[next]);
            run_process(q, next, q->data[next].run_time);
            time += q->data[next].run_time;
        } else {
            time++;
        }
    }
}

void rr_scheduler(Queue *q, int quantum) {
    int time = 0, next;
    while (!is_queue_empty(q)) {
        next = get_next_process_rr(q, time);
        if (next >= 0) {
            q->data[next].state = 2;
            print_process(q->data[next]);
            run_process(q, next, quantum);
            time += quantum;
        } else {
            time++;
        }
    }
}

int main() {
    Queue q;
    init_queue(&q);
    create_processes(&q);
    print_queue(&q);
    printf("FCFS Schedule:\n");
    fcfs_scheduler(&q);
    init_queue(&q);
    create_processes(&q);
    print_queue(&q);
    printf("SJF Schedule:\n");
    sjf_scheduler(&q);
    init_queue(&q);
    create_processes(&q);
    print_queue(&q);
    printf("RR Schedule:\n");
    rr_scheduler(&q, 2);
    return 0;
}

以上是一个简要的实验报告示例，仅供参考。实际实验中，由于涉及到具体的实现方式和测试数据，可能需要根据具体情况进行修改和补充。