【进程调度模拟】Linux “操作系统进程调度算法模拟：时间片轮转、优先级调度与先来先服务“

---

1. 基于时间片轮转（Round Robin, RR）调度算法模拟

目的：模拟时间片轮转调度算法，理解其工作原理和公平性。

步骤：

1. 初始化：设定时间片（quantum）的大小，创建一个就绪队列。
2. 进程到达：将到达的进程按照到达顺序加入到就绪队列中。
3. 调度：从就绪队列中取出队首进程，运行一个时间片的长度。
4. 时间片结束：如果进程未完成，将其放回就绪队列的队尾；如果完成，则从队列中移除。
5. 重复：重复步骤3和4，直到所有进程都完成。
6. 记录：记录每个进程的等待时间和周转时间。
7. 流程图：
   
8. 时间片轮转调度算法模拟C语言：

#include<stdio.h>
#include<stdlib.h>
#define MAX 10   //最大进程数
int Time;   //时间片
int process_amount;  //进程数量
int current_number = 0;   //当前执行的“号码牌”
int index = 0;       //就绪队列要发的“号码牌”，初始值为0
struct PCB
{char name[10];   //进程名字int arrival_time;   //到达时间int service_time;   //服务时间int completion_time;   //完成时刻int sign_completion;  //标志是否完成调用，0表示没完成，1表示完成int remaining_time;  //剩余服务时间int number;          //进程在就绪队列里的“号码牌”
}process[MAX];void input()     //初始化进程的信息
{int i;printf("请输入时间片：\n");scanf("%d",&Time);printf("请输入进程名称、到达时间、服务时间：\n");for(i = 0; i < process_amount; i ++){printf("%d号进程:\n",i+1);scanf("%s%d%d",process[i].name,&process[i].arrival_time,&process[i].service_time);printf("\n");process[i].remaining_time = process[i].service_time;process[i].sign_completion = 0;process[i].number = 0;       //“号码牌”初始为0}
}void BubbleSort()    //冒泡排序算法对进程抵达时间先后排序
{int i,j,n = process_amount;for(i = 0; i < n - 1; i++)for(j = 0; j < n - 1 - i; j++){if(process[j].arrival_time > process[j+1].arrival_time){process[n] = process[j+1];process[j+1] = process[j];process[j] = process[n];}}
}void RunProcess()     //时间片轮转调用过程
{int time = process[0].arrival_time;      //给当前时间赋初值int sum = 0;					//记录完成的进程数int i,j;while(sum < process_amount){for(i = 0;  i < process_amount; i++)if(current_number == process[i].number && process[i].sign_completion == 0){if(process[i].remaining_time <= Time)    //剩余服务时间少于等于一个时间片{time = time + process[i].remaining_time;process[i].sign_completion = 1;process[i].completion_time = time;process[i].remaining_time = 0;printf("%s ",process[i].name);sum++;current_number++;for(j = i + 1; j < process_amount; j++)     //检测后面有没有新进程到达if(process[j].arrival_time <= time && process[j].number == 0){index++;process[j].number = index;}}else if(process[i].remaining_time > Time)//剩余服务时间大于一个时间片{time = time + Time;process[i].remaining_time -= Time;printf("%s ",process[i].name);current_number++;for(j = i + 1; j < process_amount; j++)    //检测后面有没有新进程到达if(process[j].arrival_time <= time && process[j].number == 0){index++;process[j].number = index;}index++;process[i].number = index;}}if(index < current_number && sum < process_amount)   // 还有没执行的进程，且没进入就绪队列{for(i = 0; i <= process_amount; i++)if(process[i].sign_completion == 0){time = process[i].arrival_time;index++;process[i].number = index;break;}}}
}void output()   //打印信息
{int i;printf("程序名 到达时间 服务时间 完成时间 周转时间  带权周转时间\n");for(i = 0; i < process_amount; i++){float weight_time = (float)(process[i].completion_time - process[i].arrival_time)/process[i].service_time;printf("  %s\t  %d\t   %d\t    %d\t     %d\t\t%.2f\n",process[i].name,process[i].arrival_time,process[i].service_time,process[i].completion_time,process[i].completion_time-process[i].arrival_time,weight_time);}
}int main()
{int f;printf("模拟时间片轮转法实现进程调度\n");printf("请输入总进程数：\n");scanf("%d",&process_amount);input();BubbleSort();printf("进程运行顺序：\n");RunProcess();printf("\n");output();printf("\n");system("pause");return 0;
}

输出:

2. 最高优先级优先（Priority Scheduling）调度算法模拟

目的：模拟最高优先级优先调度算法，理解其对进程优先级的处理。

步骤：

1. 初始化：为每个进程分配一个优先级，创建一个就绪队列。
2. 进程到达：将到达的进程加入到就绪队列中，并根据优先级排序。
3. 调度：选择就绪队列中优先级最高的进程执行。
4. 进程完成：执行完成后，从队列中移除该进程。
5. 重复：重复步骤3和4，直到所有进程都完成。
6. 记录：记录每个进程的等待时间和周转时间。
7. 流程图：
   
8. 最高优先级优先调度算法模拟 C语言代码实现

#include <stdio.h>
#include <string.h>#define MAX_PROCESSES 10typedef struct {char name[10];       // 进程名称int arrival_time;    // 到达时间int service_time;    // 服务时间int priority;        // 优先级，数值越小优先级越高int completion_time; // 完成时间int remaining_time;  // 剩余服务时间
} Process;Process processes[MAX_PROCESSES];
int process_count; // 实际进程数量// 函数声明
void input_processes();
void sort_processes_by_priority();
void schedule_processes();
void print_schedule();int main() {printf("模拟最高优先级优先调度算法\n");printf("请输入进程数（1-%d）：\n", MAX_PROCESSES);scanf("%d", &process_count);input_processes();sort_processes_by_priority();schedule_processes();print_schedule();return 0;
}void input_processes() {printf("请输入每个进程的名称、到达时间、服务时间和优先级：\n");for (int i = 0; i < process_count; ++i) {printf("进程 %d:\n", i + 1);scanf("%s %d %d %d", processes[i].name, &processes[i].arrival_time, &processes[i].service_time, &processes[i].priority);processes[i].completion_time = 0;processes[i].remaining_time = processes[i].service_time;}
}void sort_processes_by_priority() {// 使用简单的选择排序算法根据优先级排序for (int i = 0; i < process_count - 1; ++i) {for (int j = 0; j < process_count - i - 1; ++j) {if (processes[j].priority > processes[j + 1].priority) {Process temp = processes[j];processes[j] = processes[j + 1];processes[j + 1] = temp;}}}
}void schedule_processes() {int current_time = 0;int completed_processes = 0;while (completed_processes < process_count) {int process_index = -1;int highest_priority = 100; // 假设优先级不会超过100// 找到当前时间点优先级最高的进程for (int i = 0; i < process_count; ++i) {if (processes[i].arrival_time <= current_time &&processes[i].remaining_time > 0 &&processes[i].priority < highest_priority) {highest_priority = processes[i].priority;process_index = i;}}// 如果当前时间点没有进程可执行，时间前进到下一个进程到达的时间if (process_index == -1) {int next_arrival_time = 100; // 假设到达时间不会超过100for (int i = 0; i < process_count; ++i) {if (processes[i].arrival_time > current_time && processes[i].arrival_time < next_arrival_time) {next_arrival_time = processes[i].arrival_time;}}current_time = next_arrival_time;continue;}// 执行进程printf("执行进程：%s\n", processes[process_index].name);if (processes[process_index].remaining_time > 0) {int execute_time = (processes[process_index].remaining_time > 1) ? 1 : processes[process_index].remaining_time;processes[process_index].remaining_time -= execute_time;current_time += execute_time;}// 如果进程完成，更新完成时间if (processes[process_index].remaining_time == 0) {processes[process_index].completion_time = current_time;completed_processes++;} else {// 如果进程未完成，更新其到达时间processes[process_index].arrival_time = current_time + 1;}}
}void print_schedule() {printf("进程名\t到达时间\t服务时间\t优先级\t完成时间\n");for (int i = 0; i < process_count; ++i) {printf("%s\t%d\t\t%d\t\t%d\t\t%d\n", processes[i].name, processes[i].arrival_time, processes[i].service_time, processes[i].priority, processes[i].completion_time);}
}

输出：

3. 先来先服务（FCFS）调度算法模拟

目的：模拟先来先服务调度算法，理解其简单性和公平性。

步骤：

1. 初始化：创建一个就绪队列。
2. 进程到达：将到达的进程按照到达顺序加入到就绪队列中。
3. 调度：从就绪队列中取出队首进程执行。
4. 进程完成：执行完成后，从队列中移除该进程。
5. 重复：重复步骤3和4，直到所有进程都完成。
6. 记录：记录每个进程的等待时间和周转时间。
7. 流程图：
   
8. FCFS调试算法模拟 C语言代码实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>#define MAX_PROCESSES 10typedef struct {char name[10];       // 进程名称int arrival_time;    // 到达时间int service_time;    // 服务时间int completion_time; // 完成时间int waiting_time;    // 等待时间int turnaround_time; // 周转时间
} Process;Process processes[MAX_PROCESSES];
int process_count; // 实际进程数量void input_processes() {printf("请输入进程数（1-%d）：\n", MAX_PROCESSES);scanf("%d", &process_count);printf("请输入每个进程的名称、到达时间和服务时间：\n");for (int i = 0; i < process_count; ++i) {printf("进程 %d:\n", i + 1);scanf("%s %d %d", processes[i].name, &processes[i].arrival_time, &processes[i].service_time);processes[i].completion_time = 0;processes[i].waiting_time = 0;processes[i].turnaround_time = 0;}
}void schedule_processes() {int current_time = 0;int completed_processes = 0;// 按到达时间排序for (int i = 0; i < process_count; ++i) {for (int j = i + 1; j < process_count; ++j) {if (processes[i].arrival_time > processes[j].arrival_time) {Process temp = processes[i];processes[i] = processes[j];processes[j] = temp;}}}for (int i = 0; i < process_count; ++i) {if (processes[i].arrival_time > current_time) {current_time = processes[i].arrival_time;}processes[i].waiting_time = current_time - processes[i].arrival_time;current_time += processes[i].service_time;processes[i].completion_time = current_time;processes[i].turnaround_time = processes[i].completion_time - processes[i].arrival_time;}
}void print_schedule() {printf("进程名\t到达时间\t服务时间\t等待时间\t周转时间\t完成时间\n");for (int i = 0; i < process_count; ++i) {printf("%s\t%d\t\t%d\t\t%d\t\t%d\t\t%d\n", processes[i].name, processes[i].arrival_time, processes[i].service_time, processes[i].waiting_time, processes[i].turnaround_time, processes[i].completion_time);}
}int main() {input_processes();schedule_processes();print_schedule();return 0;
}

输出：