操作系统 进程调度实验代码

一、实验目的通过本次实验，加深对进程调度原理和算法的理解，掌握进程调度程序的设计与实现方法。

实验要求我们使用高级编程语言编写一个简单的进程调度程序，实现不同调度算法的模拟，并通过实验验证算法的性能。

二、实验环境1. 操作系统：Windows 102. 编程语言：Java3. 开发工具：IntelliJ IDEA三、实验内容本次实验主要实现以下调度算法：1. 先来先服务（FCFS）2. 最短作业优先（SJF）3. 时间片轮转（RR）四、实验步骤1. 定义进程类（Process）：```javapublic class Process {private String processName; // 进程名称private int arrivalTime; // 到达时间private int burstTime; // 运行时间private int waitingTime; // 等待时间private int turnaroundTime; // 周转时间// 构造函数public Process(String processName, int arrivalTime, int burstTime) {this.processName = processName;this.arrivalTime = arrivalTime;this.burstTime = burstTime;}// 省略getter和setter方法}```2. 定义调度器类（Scheduler）：```javapublic class Scheduler {private List<Process> processes; // 进程列表private int currentTime; // 当前时间// 构造函数public Scheduler(List<Process> processes) {this.processes = processes;this.currentTime = 0;}// FCFS调度算法public void fcfs() {for (Process process : processes) {process.setWaitingTime(currentTime -process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime -process.getArrivalTime());}}// SJF调度算法public void sjf() {processes.sort((p1, p2) -> p1.getBurstTime() -p2.getBurstTime());for (Process process : processes) {process.setWaitingTime(currentTime -process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime -process.getArrivalTime());}}// RR调度算法public void rr(int quantum) {List<Process> sortedProcesses = new ArrayList<>(processes);sortedProcesses.sort((p1, p2) -> p1.getArrivalTime() -p2.getArrivalTime());int timeSlice = quantum;for (Process process : sortedProcesses) {if (process.getBurstTime() > timeSlice) {process.setWaitingTime(currentTime - process.getArrivalTime());currentTime += timeSlice;process.setTurnaroundTime(currentTime - process.getArrivalTime());process.setBurstTime(process.getBurstTime() - timeSlice);} else {process.setWaitingTime(currentTime - process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime - process.getArrivalTime());process.setBurstTime(0);}}}}```3. 测试调度程序：```javapublic class Main {public static void main(String[] args) {List<Process> processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P3", 4, 2));processes.add(new Process("P4", 6, 4));Scheduler scheduler = new Scheduler(processes); System.out.println("FCFS调度结果：");scheduler.fcfs();for (Process process : processes) {System.out.println(process);}processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P2", 1, 3));processes.add(new Process("P3", 4, 2));processes.add(new Process("P4", 6, 4));System.out.println("SJF调度结果：");scheduler.sjf();for (Process process : processes) {System.out.println(process);}processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P2", 1, 3));processes.add(new Process("P3", 4, 2));System.out.println("RR调度结果（时间片为2）：");scheduler.rr(2);for (Process process : processes) {System.out.println(process);}}}```五、实验结果与分析通过实验，我们可以观察到以下结果：1. FCFS调度算法简单，但可能导致长作业等待时间过长。

第1篇---进程管理实验报告一、实验目的1. 理解进程的概念和进程管理的基本原理。

2. 掌握进程的创建、调度、同步和通信等操作。

3. 通过编程实现简单的进程管理功能。

二、实验环境1. 操作系统：Windows/Linux2. 编程语言：C/C++3. 开发环境：Visual Studio/Code::Blocks三、实验内容1. 进程的创建与终止2. 进程的同步与互斥3. 进程的通信4. 进程调度算法四、实验步骤1. 进程的创建与终止```cinclude <stdio.h>include <sys/types.h>include <unistd.h>int main() {pid_t pid;// 创建子进程pid = fork();if (pid < 0) {// 创建进程失败perror("fork failed");return 1;} else if (pid == 0) {// 子进程printf("Child process, PID: %d\n", getpid()); // 执行子进程的任务...sleep(5); // 子进程暂停5秒_exit(0); // 子进程退出} else {// 父进程printf("Parent process, PID: %d\n", getpid()); wait(NULL); // 等待子进程结束printf("Child process has terminated.\n");}return 0;}```2. 进程的同步与互斥```cinclude <stdio.h>include <pthread.h>pthread_mutex_t mutex;void thread_func(void arg) {pthread_mutex_lock(&mutex); // 加锁printf("Thread %ld is running\n", (long)arg);sleep(1); // 模拟任务执行pthread_mutex_unlock(&mutex); // 解锁return NULL;}int main() {pthread_t thread1, thread2;// 初始化互斥锁pthread_mutex_init(&mutex, NULL);// 创建线程pthread_create(&thread1, NULL, thread_func, (void )1); pthread_create(&thread2, NULL, thread_func, (void )2); // 等待线程结束pthread_join(thread1, NULL);pthread_join(thread2, NULL);// 销毁互斥锁pthread_mutex_destroy(&mutex);return 0;}```3. 进程的通信```cinclude <stdio.h>include <stdlib.h>include <sys/ipc.h>include <sys/shm.h>int main() {key_t key;int shmid;int data;// 生成共享内存标识符key = ftok("shmfile", 65);// 创建共享内存段shmid = shmget(key, sizeof(int), 0666 | IPC_CREAT); if (shmid == -1) {perror("shmget failed");exit(1);}// 连接到共享内存段data = (int )shmat(shmid, (void )0, 0);if (data == (int )(-1)) {perror("shmat failed");exit(1);}// 使用共享内存data = 100;printf("Data in shared memory: %d\n", data); // 分离共享内存段if (shmdt(data) == -1) {perror("shmdt failed");exit(1);}// 删除共享内存段if (shmctl(shmid, IPC_RMID, NULL) == -1) { perror("shmctl failed");exit(1);}return 0;}```4. 进程调度算法```cinclude <stdio.h>include <stdlib.h>include <sys/time.h>typedef struct {int pid;int arrival_time;int burst_time;int waiting_time;int turnaround_time;} Process;int main() {Process processes[] = {{1, 0, 5, 0, 0},{2, 1, 3, 0, 0},{3, 4, 8, 0, 0}};int n = sizeof(processes) / sizeof(processes[0]);// 计算等待时间和周转时间int total_waiting_time = 0, total_turnaround_time = 0;for (int i = 0; i < n; i++) {if (i == 0) {processes[i].waiting_time = 0;} else {processes[i].waiting_time = processes[i - 1].turnaround_time;}processes[i].turnaround_time = processes[i].burst_time + processes[i].waiting_time;total_waiting_time += processes[i].waiting_time;total_turnaround_time += processes[i].turnaround_time;}printf("Average Waiting Time: %f\n", (float)total_waiting_time / n);printf("Average Turnaround Time: %f\n", (float)total_turnaround_time / n);return 0;}```五、实验结果与分析（此处应填写实验结果，包括运行程序输出、图表等，以及对实验结果的分析。

1. 实验内容编写一个单处理机下的进程调度程序，模拟操作系统对进程的调度。

2. 实验目的进程是操作系统中最基本、最重要的概念，进程调度又是操作系统的核心模块。

本实验要求学生独立设计并实现进程调度模拟程序，以加深对进程控制块概念和各种进程调度算法的理解。

3. 实验要求可以随机输入若干进程，支持先来先服务、短作业优先、最短剩余时间优先、时间片轮转、动态优先级调度算法，能够输出进程的调度过程。

4. 程序中使用的数据结构及符号说明(1). PCB （进程控制块）1.struct pcb2.{3.int id;4.int arrive;5.int run;6.int priority;7.int time;8.bool done;9.};说明：在进程控制块中记录了以下信息：(2). PCB数组1.struct pcb process[N];说明：process数组用于保存调度所涉及的进程的信息。

5. 各种调度算法的处理流程，重要模块的详细设计及功能和接口说明(1). 预处理算法流程对应程序代码及注释1.int main()2.{3.// 初始化PCB数组4. memset(process,0,sizeof(process));5.// 读入调度类型6.int type;7. scanf("%d",&type);8.// 读入调度进程数据9.for( n =0;~scanf("%d/%d/%d/%d/%d",10.&process[n].id,11.&process[n].arrive,12.&process[n].run,13.&process[n].priority,14.&process[n].time); n ++);15.// 根据调度类型转到子程序进行调度16.switch( type )17.{18.// 各调度子程序：19.case1: fcfs();break;// 先来先服务20.case2: sjf();break;// 短作业优先21.case3: sltf();break;// 最短剩余时间优先22.case4: tpt();break;// 时间片轮转23.case5: dp();break;// 动态优先级24.}25.return0;26.}(2). 先来先服务算法逻辑流程本题中算法实际流程对应程序代码及注释1.void fcfs()2.{3.// 按到达时间、pid排序4. sort(process, process+n, cmp_ar_id);5.// 初始化系统时间6.int time =0;7.// 顺序遍历各进程8.for(int i =0; i < n; i ++)9.{10.// 若当前系统时间时没有待调度进程11.if( time < process[i].arrive )12.{13.// 等待系统时间到达下一个进程到来14. time = process[i].arrive;15.}16.// 否则17.// 进行进程调度18. printf("%d/%d/%d/%d/%d\n", i+1, process[i].id, time, time +process[i].run, process[i].priority);19.// 进程运行，系统时间流逝20. time += process[i].run;21.}22.return;23.}(3). 短作业优先算法逻辑流程本题中算法实际流程对应程序代码及注释1.void sjf()2.{3.// 按运行时间、pid排序4. sort(process, process+n, cmp_run_id);5.// 初始化系统时间6.int time =0;7.// 有未运行进程8.for(int m =1; m <= n;)9.{10.// 找出已到达的未运行进程中，运行时间最短的进程11.int min = INT_MAX, mini =-1;12.for(int i =0; i < n; i ++)13.{14.if( process[i].arrive <= time &&// 已到达的进程15. process[i].run < min &&// 运行时间最短的进程16.! process[i].done)// 未运行的进程17.{18. min = process[i].run;19. mini = i;20.}21.}22.// 若当前系统时间时没有待调度进程23.if(-1== mini )24.{25.// 找出下一个到达的时间26.int mint = INT_MAX;27.for(int i =0; i < n; i ++)28.{29.if( process[i].arrive < mint &&// 最近的到达时间30.! process[i].done)// 未运行的进程31.{32. mint = process[i].arrive;33.}34.}35.// 等待系统时间到达下一个进程到来36. time = mint;37.continue;38.}39.// 否则40.// 进行进程调度41. printf("%d/%d/%d/%d/%d\n", m, process[mini].id, time, time +process[mini].run, process[mini].priority);42.// 进程运行，系统时间流逝43. time += process[mini].run;44. process[mini].done=true;45.// 已运行进程数+146. m ++;47.}48.}(4). 最短剩余时间优先算法逻辑流程本题中算法实际流程主流程：调度器配置阶段：预调度阶段：进程调度阶段：进程运行阶段：对应程序代码及注释1.void sltf()2.{3./********** 调度器配置阶段 **********/4.// 按到达时间、运行时间、pid排序5. sort(process, process+n, cmp_run);6.// 初始化系统时间7.int time = process[0].arrive;8.// 初始化调度程序配置9.int execi =-1, start = time;10.int k =0, m =0;11.// 有未运行进程12.for(int i =0; m < n;)13.{14./********** 预调度阶段 **********/15.// 找到在当前系统时间已经到达的进程16.for(; process[i].arrive <= time && i < n; i ++);17.// 在已到达进程中查找剩余运行时间最短的未结束进程18.int min = INT_MAX, mini =-1;19.for(int j =0; j < i; j ++)20.{21.if( process[j].run < min &&! process[j].done)22.{23. min = process[j].run;24. mini = j;25.}26.}27.// 若在当前系统时间之前到达的进程均已经结束28.if(-1== mini )29.{30.// 等待下一个进程到达后重新进行调度31. time = process[i].arrive;32.continue;33.}34.// 若当前没有正在运行的进程35.if(-1== execi )36.{37.// 则执行找到的进程38. execi = mini;39.// 进程的开始运行时间设为现在的时间40. start = std::max(process[execi].arrive, time);41.}42./********** 进程调度阶段 **********/43.// 若找到的进程剩余运行时间小于当前正在运行进程的剩余运行时间44.if( process[mini].run < process[execi].run )45.{46.// 则进行调度47. printf("%d/%d/%d/%d/%d\n",++ k, process[execi].id, start, time, process[execi].priority);48. execi = mini;49. start = time;50.}51./********** 进程运行阶段 **********/52.// 运行进程53.int runnable = process[i].arrive - time;54.// 若进程可以完成运行则将进程运行完55.if( runnable >= process[execi].run || runnable <=0)56.{57. time += process[execi].run;58. printf("%d/%d/%d/%d/%d\n",++ k, process[execi].id, start, time, process[execi].priority);59. process[execi].run =0;60. process[execi].done=true;61. m ++;62. execi =-1;63. start = time;64.}65.// 若进程不能完成运行则运行一个时间片66.else67.{68. time += runnable;69. process[execi].run -= runnable;70.}71.}72.return;73.}74.(5). 时间片轮转算法逻辑流程本题中算法实际流程对应程序代码及注释1.void tpt()2.{3.// 初始化进程队列4. queue<pcb> qu;5. process[n].arrive = INT_MAX;6.// 按到达时间、pid排序7. sort(process, process+n, cmp_ar_id);8.// 初始化系统时间9.int time = process[0].arrive;10.// 所有进程是否均完成运行11.for(int i =0, k =1, m =0; m < n;)12.{13.// 如果队列为空14.if( qu.empty())15.{16.// 等待新的进程到达17. time = process[i].arrive;18.// 将当前系统时间之前的进程放入队列19.for(; process[i].arrive <= time && i < n; i ++)20.{21. qu.push(process[i]);22.}23.}24.// 取队首进程25. pcb temp = qu.front();26. qu.pop();27.// 如果进程不能完成运行28.if( temp.run > temp.time )29.{30.// 进程调度31. printf("%d/%d/%d/%d/%d\n", k ++, temp.id, time, time + temp.time, temp.priority);32.// 将进程运行一个时间片33. time += temp.time;34. temp.run -= temp.time;35.// 将当前系统时间之前的进程放入队列36.for(; process[i].arrive <= time && i < n; i ++)37.{38. qu.push(process[i]);39.}40.// 将进程放回队列41. qu.push(temp);42.}43.// 如果进程可以完成运行44.else45.{46.// 进程调度47. printf("%d/%d/%d/%d/%d\n", k ++, temp.id, time, time + temp.run, temp.priority);48.// 将进程运行完49. time += temp.run;50.// 将当前系统时间之前的进程放入队列51.for(; process[i].arrive <= time && i < n; i ++)52.{53. qu.push(process[i]);54.}55. m ++;56.}57.}58.return;59.}(6). 动态优先级算法逻辑流程本题中算法实际流程对应程序代码及注释1.void dp()2.{3.// 按到达时间、pid排序4. sort(process, process+n, cmp_ar_id);5.// 初始化系统时间6.int time = process[0].arrive;7.int last= time;8.int min, mini =-1;9.for(int i =0, k =1, m =0; m < n;)10.{11.// 找到在当前系统时间已经到达的进程12.for(; process[i].arrive <= time && i < n; i ++)13.{14.// 若进程在时间片中间到达，则算作是运行了一个时间片，优先级+115.if(last< process[i].arrive && process[i].arrive < time)16.{17. process[i].priority =(process[i].priority -1>0)?(process[i].priority -1):0;18.}19.}20.// 找到优先级最高的进程21. min = INT_MAX, mini =-1;22.for(int j =0; j < i; j ++)23.{24.if( process[j].priority < min &&! process[j].done)25.{26. min = process[j].priority;27. mini = j;28.}29.}30.// 若在当前系统时间之前到达的进程均已经结束31.if(-1== mini )32.{33.// 等待下一个进程到达后重新进行调度34. time = process[i].arrive;35.continue;36.}st= time;38.// 如果进程可以运行完39.if( process[mini].run <= process[mini].time )40.{41.// 进程调度42. printf("%d/%d/%d/%d/%d\n", k ++, process[mini].id, time,time + process[mini].run, process[mini].priority +3);43.// 将进程运行完44. m ++;45. time += process[mini].run;46. process[mini].done=true;47.}48.// 如果进程不能运行完49.else50.{51.// 进程调度52. printf("%d/%d/%d/%d/%d\n", k ++, process[mini].id, time,time + process[mini].time, process[mini].priority +3);53.// 将进程运行一个时间片54. time += process[mini].time;55. process[mini].run -= process[mini].time;56.}57.// 调整进程优先级58.for(int j =0; j < i; j ++)59.{60.if(! process[j].done)61.{62.// 若被运行，优先级-363.if( j == mini )64.{65. process[j].priority +=3;66.}67.// 若未被运行，优先级+168.else69.{70. process[j].priority =71.(process[j].priority -1>0)?(process[j].priority -1):0;72.}73.}74.}75.}76.return;77.}6. 程序完整代码及注释#include<algorithm>#include<queue>#include<cstdio>#include<climits>#include<cstring>using std::sort;using std::queue;const int N =100;// 定义PCB数组大小int n;// 保存进程的总个数struct pcb // PCB （进程控制块）{int id;// 进程号pidint arrive;// 进程到达时间int run;// 进程运行时间int priority;// 进程优先级int time;// 进程运行的时间片bool done;// 记录进程是否已经完成运行} process[N];// PCB数组// 按到达时间、pid排序bool cmp_ar_id(pcb a, pcb b){if(a.arrive == b.arrive){return a.id < b.id;}else{return a.arrive < b.arrive;}}// 按运行时间、pid排序bool cmp_run_id(pcb a, pcb b){if(a.run == b.run){return a.id < b.id;}else{return a.run < b.run;}}// 按到达时间、运行时间、pid排序bool cmp_run(pcb a, pcb b){if(a.arrive == b.arrive){if(a.run == b.run){return a.id < b.id;}else{return a.run < b.run;}}else{return a.arrive < b.arrive;}}// 先来先服务void fcfs(){// 按到达时间、pid排序sort(process, process+n, cmp_ar_id);// 初始化系统时间int time =0;// 顺序遍历各进程for(int i =0; i < n; i ++){// 若当前系统时间时没有待调度进程if( time < process[i].arrive ){// 等待系统时间到达下一个进程到来time = process[i].arrive;}// 否则// 进行进程调度printf("%d/%d/%d/%d/%d\n", i+1, process[i].id, time, time + pro cess[i].run, process[i].priority);// 进程运行，系统时间流逝time += process[i].run;}return;}// 短作业优先void sjf(){// 按运行时间、pid排序sort(process, process+n, cmp_run_id);// 初始化系统时间int time =0;// 有未运行进程for(int m =1; m <= n;){// 找出已到达的未运行进程中，运行时间最短的进程int min = INT_MAX, mini =-1;for(int i =0; i < n; i ++){if( process[i].arrive <= time &&// 已到达的进程process[i].run < min &&// 运行时间最短的进程! process[i].done)// 未运行的进程{min = process[i].run;mini = i;}}// 若当前系统时间时没有待调度进程if(-1== mini ){// 找出下一个到达的时间int mint = INT_MAX;for(int i =0; i < n; i ++){if( process[i].arrive < mint &&// 最近的到达时间! process[i].done)// 未运行的进程{mint = process[i].arrive;}}// 等待系统时间到达下一个进程到来time = mint;continue;}// 否则// 进行进程调度printf("%d/%d/%d/%d/%d\n", m, process[mini].id, time, time + pr ocess[mini].run, process[mini].priority);// 进程运行，系统时间流逝time += process[mini].run;process[mini].done=true;// 已运行进程数+1m ++;}}// 最短剩余时间优先void sltf(){/********** 调度器配置阶段 **********/// 按到达时间、运行时间、pid排序sort(process, process+n, cmp_run);// 初始化系统时间int time = process[0].arrive;// 正在运行的进程置空，进程开始运行时间置为系统当前时间int execi =-1, start = time;int k =0, m =0;// 有未运行进程for(int i =0; m < n;){/********** 预调度阶段 **********/// 找到在当前系统时间已经到达的进程for(; process[i].arrive <= time && i < n; i ++);// 在已到达进程中查找剩余运行时间最短的未结束进程int min = INT_MAX, mini =-1;for(int j =0; j < i; j ++){if( process[j].run < min &&! process[j].done){min = process[j].run;mini = j;}}// 若在当前系统时间之前到达的进程均已经结束if(-1== mini ){// 等待下一个进程到达后重新进行调度time = process[i].arrive;continue;}// 若当前没有正在运行的进程if(-1== execi ){// 则执行找到的进程execi = mini;// 进程的开始运行时间设为现在的时间start = std::max(process[execi].arrive, time);}/********** 进程调度阶段 **********/// 若找到的进程剩余运行时间小于当前正在运行进程的剩余运行时间if( process[mini].run < process[execi].run ){// 则进行调度printf("%d/%d/%d/%d/%d\n",++ k, process[execi].id, start, t ime, process[execi].priority);execi = mini;start = time;}/********** 进程运行阶段 **********/// 运行进程int runnable = process[i].arrive - time;// 若进程可以完成运行则将进程运行完if( runnable >= process[execi].run || runnable <=0){time += process[execi].run;printf("%d/%d/%d/%d/%d\n",++ k, process[execi].id, start, t ime, process[execi].priority);process[execi].run =0;process[execi].done=true;m ++;execi =-1;start = time;}// 若进程不能完成运行则运行一个时间片else{time += runnable;process[execi].run -= runnable;}}return;}// 时间片轮转void tpt(){// 初始化进程队列queue<pcb> qu;process[n].arrive = INT_MAX;// 按到达时间、pid排序sort(process, process+n, cmp_ar_id);// 初始化系统时间int time = process[0].arrive;// 所有进程是否均完成运行for(int i =0, k =1, m =0; m < n;) {// 如果队列为空if( qu.empty()){// 等待新的进程到达time = process[i].arrive;// 将当前系统时间之前的进程放入队列for(; process[i].arrive <= time && i < n; i ++){qu.push(process[i]);}}// 取队首进程pcb temp = qu.front();qu.pop();// 如果进程不能完成运行if( temp.run > temp.time ){// 进程调度printf("%d/%d/%d/%d/%d\n", k ++, temp.id, time, time + temp. time, temp.priority);// 将进程运行一个时间片time += temp.time;temp.run -= temp.time;// 将当前系统时间之前的进程放入队列for(; process[i].arrive <= time && i < n; i ++){qu.push(process[i]);}// 将进程放回队列qu.push(temp);}// 如果进程可以完成运行else{// 进程调度printf("%d/%d/%d/%d/%d\n", k ++, temp.id, time, time + temp. run, temp.priority);// 将进程运行完time += temp.run;// 将当前系统时间之前的进程放入队列for(; process[i].arrive <= time && i < n; i ++){qu.push(process[i]);}m ++;}}return;}// 动态优先级void dp(){// 按到达时间、pid排序sort(process, process+n, cmp_ar_id);// 初始化系统时间int time = process[0].arrive;int last= time;int min, mini =-1;// 所有进程是否均完成运行for(int i =0, k =1, m =0; m < n;){// 找到在当前系统时间已经到达的进程for(; process[i].arrive <= time && i < n; i ++){// 若进程在时间片中间到达，则算作是运行了一个时间片，优先级+1if(last< process[i].arrive && process[i].arrive < time ){process[i].priority =(process[i].priority -1>0)?(proc ess[i].priority -1):0;}}// 找到优先级最高的进程min = INT_MAX, mini =-1;for(int j =0; j < i; j ++){if( process[j].priority < min &&! process[j].done){min = process[j].priority;mini = j;}}// 若在当前系统时间之前到达的进程均已经结束if(-1== mini ){// 等待下一个进程到达后重新进行调度time = process[i].arrive;continue;}last= time;// 如果进程可以完成运行if( process[mini].run <= process[mini].time ){// 进程调度printf("%d/%d/%d/%d/%d\n", k ++, process[mini].id, time, tim e + process[mini].run, process[mini].priority +3);// 将进程运行完m ++;time += process[mini].run;process[mini].done=true;}// 如果进程不能完成运行else{// 进程调度printf("%d/%d/%d/%d/%d\n", k ++, process[mini].id, time, tim e + process[mini].time, process[mini].priority +3);// 将进程运行一个时间片time += process[mini].time;process[mini].run -= process[mini].time;}// 调整进程优先级for(int j =0; j < i; j ++){if(! process[j].done){// 若被运行，优先级-3if( j == mini ){process[j].priority +=3;}// 若未被运行，优先级+1else{process[j].priority =(process[j].priority -1>0)?(process[j].priorit y -1):0;}}}}return;}int main(){// 初始化PCB数组memset(process,0,sizeof(process));// 读入调度类型int type;scanf("%d",&type);// 读入调度进程数据for( n =0;~scanf("%d/%d/%d/%d/%d",&process[n].id,&process[n].arrive,&process[n].run,&process[n].priority,&process[n].time); n ++);// 根据调度类型转到子程序进行调度switch( type ){// 各调度子程序：case1: fcfs();break;// 先来先服务case2: sjf();break;// 短作业优先case3: sltf();break;// 最短剩余时间优先case4: tpt();break;// 时间片轮转case5: dp();break;// 动态优先级}return0;}7. 采用的测试方法，对测试结果以及错误的分析(1). 采用的测试方法•对于本实验中的程序主要采用的测试方法是白盒测试•对于提交后有无法通过的测试用例时采用了其他已经通过同学的测试用例进行了黑盒测试•对于测试用例中未明确指出的情况对测试数据进行了暴力猜解(2). 对测试结果以及错误的分析•白盒测试主要用于检测程序的边界数据的执行情况，目的是要走过程序中的全部路径。

操作系统进程调度C语言代码#include <stdio.h>#define MAX 20//进程控制块typedef struct PCBchar name[10]; // 进程名int AT; // 到达时间int BT; // 服务时间int Pri; // 优先数int FT; // 完成时间int WT; //等待时间int RT; // 响应时间int position; // 第几号进程int flag; // 用来判断进程是否执行过}PCB;//进程调度void schedule(PCB a[], int n, int alg)int i, j, k, flag, temp;int count = 0;int pri_max = 0;float ATAT = 0.0;float AWT = 0.0;float ART = 0.0;PCBt;//各种算法的调度if (alg == 1)printf("采用先来先服务调度：\n"); //根据到达时间执行for (i = 0; i < n; i++)for (j = i + 1; j < n; j++)if (a[i].AT > a[j].AT)t=a[i];a[i]=a[j];a[j]=t;}//按到达时间依次执行for (i = 0; count != n; i++)for (j = 0; j < n; j++)//查找第一个到达时间小于等于当前时间的进程if (a[j].AT <= i && a[j].flag == 0)//记录运行时间a[j].BT--;//如果运行完成，记录完成时间、等待时间、响应时间if (a[j].BT == 0)a[j].FT=i+1;a[j].WT = a[j].FT - a[j].AT - a[j].Pri;a[j].RT=a[j].WT;a[j].flag = 1;count++;}elsebreak;}}}else if (alg == 2)printf("采用最短服务时间优先（非抢占）调度：\n");for (i = 0; count != n; i++)//找出服务时间最短的进程，并将其放置到最前面for (j = 0; j < n; j++)。

进程调度算法实现//数据：进程，队列结构//处理流程：//1 初始化--进程队列结构（包括：就绪队列，等待队列，运行队列）等必要的数据结构init(); //2 进入无限循环，反复调度队列#define MAX 5#include<stdio.h>#include<stdlib.h>int total_time=20;int time_slice=3;typedef struct process { // 进程控制块char pname[10];int WaitTime;int BurstTime;int priority; // 数字越小优先级越高struct process *next;}PROCESS;//typedef struct process PROCESS;PROCESS * in_queue(PROCESS *head,PROCESS *p); //声明PROCESS *init() //进程初始化{int i=0;char a;PROCESS *head_new; //队列的队头head_new=(struct process*)malloc(sizeof(struct process));if(!head_new) exit(1);head_new=NULL;do{struct process *s;printf("initialize the process:\n");s=(struct process *)malloc(sizeof(struct process));if(!s) exit(1);printf("please input the pname:WaitTime: BurstTime: priority:\n");scanf("%c",&(s->pname));scanf("%d",&(s->WaitTime));scanf("%d",&(s->BurstTime));scanf("%d",&(s->priority));s->next=NULL;in_queue(head_new,s);i++;printf("do u want to insert process more ?? 'Y'or'N'\n");printf("----------------------------------------'\n");scanf("%c",&a);scanf("%c",&a);// if(a=='Y'||a=='y') continue;// else if(a=='N'||a=='n') break;}while((i<MAX) &&(a=='Y'||a=='y'));return head_new;}///////////////////////////////////////////////////////////PROCESS *in_queue(PROCESS *head,PROCESS *p) //入队函数 {if(head==NULL){head=p;p->next=NULL;}else{p->next=head;head=p;}// printf("the process insert into the mothball queue :\n");return head;}//////////////////////////////////////////////////////////////*void new_queue() //后备队列先来先服务方式进入就绪{return *head_new;}*/PROCESS *FCFS_process(){PROCESS *p,*q,*a; //a用来记录选中结点的前一个结点q=p=init(); //这里是不是有个问题？？while(p->next!=NULL){a=p;if(p->WaitTime>=q->WaitTime){q=p;p=p->next;}}q->WaitTime--;if(q->WaitTime==0) //如果等待时间为0则把该进程从后备队列中移除{a->next=p->next;free(p);}return q; //选择等待时间最久的）}//////////////////////就绪队列，入口函数为就绪队列的头指针/////////////int count=0;PROCESS *ready_queue(PROCESS *head) //就绪队列优先级进入运行4道 {PROCESS *p;while(count<4){p=FCFS_process();p->next=head->next;head=p;count++;printf("the process has inserted into the ready queue :\n"); }return head;}//insert_ready() //PROCESS *high_priority(PROCESS *P) //选择优先级最高的进程 {PROCESS *q,*p; //问题，入口形参中q=p;while(p->next!=NULL){if(q->priority>p->priority)q=p;p=p->next;}return q;}PROCESS *pick_ready(PROCESS *a) //从就绪队列中选择进程运行 {PROCESS *p=ready_queue(a);PROCESS *b=high_priority(p);return b;}void run(PROCESS *a) //运行一个时间片{while((time_slice>0)&&(a->BurstTime>0)) //指针用-> 变量用. {printf("the process %c is runing",a->pname);printf("the process BurstTime time is %d ",a->WaitTime);printf("the process BurstTime time is %d ",a->BurstTime);printf("the process priority is %d ",a->priority);a->BurstTime--;time_slice--;}a->priority--;total_time--;/*if(a->runtime>0)return a;else return NULL;*/}void main(){PROCESS *p;PROCESS *head=init();while(total_time!=0) {ready_queue(head); p=pick_ready(head);if(p->BurstTime==0) {p=p->next;free(p);count--;}run(p);time_slice=3;}}原文已完。

实验五进程调度模拟实验//进程调度算法proc.c#include <stdio.h>#include<stdlib.h>#include <string.h>typedef struct pcb//定义PCB结构{char name[20]; /*进程标识符*/int cputime; /*进程占用CPU时间*/int prio; /*进程优先数*/int needtime; /*进程到完成还需要的CPU时间*/struct pcb *next;/*链指针*/}PCB;PCB *RUN,*READY,*RTAIL,*FINSH,*FTAIL;void PRINTLINK(int t)/*输出3个队列*/{PCB *p;printf("CPU运行次数:___%d___\n",t);printf("______________________\n");printf("进程名\t运行状态\t运行次数\t还需要运行次数\n");if(RUN!=NULL){printf("%s\t运行\t%d\t%d\n",RUN->name,RUN->cputime,RUN->needtime);}elseprintf("*运行状态为空\n");p=READY;if(p!=NULL){while(p!=NULL){printf("%s\t就绪\t%d\t%d\n",p->name,p->cputime,p->needtime);p=p->next;}}elseprintf("*就绪队列为空\n");p=FINSH;if (p!=NULL){while(p!=NULL){//printf(" 进程名字为:%s\n",p->name);printf("%s\t完成\t%d\t%d\n",p->name,p->cputime,p->needtime);p=p->next;}}elseprintf("*完成队列为空\n");getchar();}PCB *CPCBLINK()/*建立就绪队列*/{printf("建立就绪队列\n\n");int i,n,nt,pr;PCB *p,*q,*head;n=0;while(1){printf("请输入进程的个数(有效范围1-100)：");scanf("%d",&n);printf("\n");if (n>=1&&n<=100)break;elseprintf("输入有误。

操作系统五种进程调度算法的代码一、先来先服务（FCFS）调度算法先来先服务（FCFS）调度算法是操作系统处理进程调度时比较常用的算法，它的基本思想是按照进程的提交时间的先后顺序依次调度进程，新提交的进程会在当前运行进程之后排队，下面通过C语言代码来实现先来先服务（FCFS）调度算法：#include <stdio.h>#include <stdlib.h>//定义进程的数据结构struct Processint pid; // 进程标识符int at; // 到达时间int bt; // 执行时间};//进程调度函数void fcfs_schedule(struct Process *processes, int n)int i, j;//根据进程的到达时间排序for(i = 0; i < n; i++)for(j = i+1; j < n; j++)if(processes[i].at > processes[j].at) struct Process temp = processes[i]; processes[i] = processes[j];processes[j] = temp;//获取各个进程执行完毕的时间int ct[n];ct[0] = processes[0].at + processes[0].bt; for(i = 1; i < n; i++)if(ct[i-1] > processes[i].at)ct[i] = ct[i-1] + processes[i].bt;elsect[i] = processes[i].at + processes[i].bt; //计算各个进程的周转时间和带权周转时间int tat[n], wt[n], wt_r[n];for(i = 0; i < n; i++)tat[i] = ct[i] - processes[i].at;wt[i] = tat[i] - processes[i].bt;wt_r[i] = wt[i] / processes[i].bt;printf("P%d:\tAT=%d\tBT=%d\tCT=%d\tTAT=%d\tWT=%d\tWT_R=%f\n", processes[i].pid, processes[i].at, processes[i].bt, ct[i], tat[i], wt[i], wt_r[i]);//主函数int mainstruct Process processes[] ={1,0,3},{2,3,5},{3,4,6},{4,5,2},{5,6,4}};fcfs_schedule(processes, 5);return 0;输出：。

//sun.cpp : 定义控制台应用程序的入口点。

//本算法包含四种调度 :先到先服务，短作业优先，时间片轮转，优先级优先！#include"stdio.h"#define N 50void main(){ void sjp(); voidfcfs();void sjf();void yxj();int a;while(true){printf("\n\n");printf("\t\t/*************************/");printf("\n\t\t/*1、先到先服务调度*/");printf("\n\t\t/*2、短作业优先调度*/");printf("\n\t\t/*3、时间片轮转调度*/");printf("\n\t\t/*4、优先级优先调度*/");printf("\n\t\t/*0、退出*/\n");printf("\t\t/*************************/");printf("\n\n\t 请选择菜单项：\t");scanf("%d",&a);printf("\n");switch(a){case 1: fcfs();break;case 2: sjf();break;case 3: sjp();break;case 4: yxj();break;default: break;}if(a<0&&a>4) break;}}void sjp(){int i,j,n,min,px,sjp,time;float sum1,sum2;bool flag=true;printf("\t请输入有n 个进程 (0<n<=50):\t");scanf("%d",&n);while(n>50||n<=0){printf("n\t请重新输入：");scanf("%d",&n);}printf("\n\n");printf("\t请输入时间片大小(0<sjp):\t"); scanf("%d",&sjp);while(sjp<=0){printf("n\t请重新输入：");scanf("%d",&sjp);}struct Gzuo{int id;// 进程名字int dt;// 到达时刻int st;// 服务时间int wct;// 完成时刻int st2; // 标志是否完成float zt;// 周转时间float dczt; // 带权周转时间};Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间：");scanf("%d",&a[i].dt);printf("\t服务时间：");scanf("%d",&a[i].st);a[i].st2 = a[i].st;printf("\n");}for(j=n -1;j>=0;j --){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].st2;a[i].st2=a[i+1].st2;a[i+1].st2=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}time = a[0].dt;//printf(" 赋值后 TIME 值为： %d\n",time);min = 0;while(min<n){flag = true;for(i = 0;i<n;i++){if(a[i].st2>0&&a[i].dt<=time)flag = false;}for(i=0;i<n;i++){if(a[i].st2 > 0 ){if(a[i].dt<=time){//printf(" 当前 a[%d].st2 值为： %d\n",i,a[i].st2);a[i].st2 = a[i].st2 - sjp;//printf(" 运算后当前a[%d].st2 值为： %d\n",i,a[i].st2);//printf(" 当前 TIME 值为： %d\n",time);time = time + sjp;//printf(" 增加之后TIME 值为： %d\n",time);if(a[i].st2<=0){a[i].wct = time + a[i].st2;a[i].zt=(float)(a[i].wct -a[i].dt);a[i].dczt=a[i].zt/a[i].st;min++;}}else if(flag){for(i=0;i<n;i++){if(a[i].st2>0&&a[i].dt>time){time = a[i].dt;break;}}}}}}printf("\t1 、按 id 号依次输出 \n");printf("\t2 、按完成顺序依次输出\n");printf("\n\t 请选择输出顺序:\t");scanf("%d",&px);printf("\nid ：到达时间 \t 服务时间 \t 完成时间 \t 周转时间 \t 带权周转时间\n"); sum1=0;sum2=0;switch(px){case 2:{for(i=0;i<n;i++){printf("%d ： %d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i].zt,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}printf("\n平均周转时间：%.2f\n",sum1/n);printf("\n平均带权周转时间：%.2f\n\n",sum2/n);break;}case 1:{for(j=0;j<n;j++){for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d ： %d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i].zt,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("\n平均周转时间：%.2f\n",sum1/n);printf("\n平均带权周转时间：%.2f\n\n",sum2/n);break;}default: break;}}void fcfs(){int i,j,n,min,px;float sum1,sum2;printf("\t请输入有n 个进程 (0<n<=50):\t");scanf("%d",&n);while(n>50||n<=0){printf("n\t请重新输入：");scanf("%d",&n);}printf("\n\n");struct Gzuo{int id; int dt; int st;// 进程名字// 到达时刻// 服务时间int wct; float zt; float dczt;// 完成时刻// 周转时间// 带权周转时间};Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间：");scanf("%d",&a[i].dt);printf("\t服务时间：");scanf("%d",&a[i].st);printf("\n");}for(j=n -1;j>=0;j --){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}a[0].wct=a[0].st+a[0].dt;a[0].zt=(float)a[0].st;a[0].dczt=a[0].zt/a[0].st;for(i=1;i<n;i++){if(a[i].dt>a[i -1].wct){a[i].wct=a[i].dt+a[i].st;a[i].zt=(float)a[i].st;a[i].dczt=a[i].zt/a[i].st;}else{a[i].wct=a[i -1].wct+a[i].st;a[i].zt=(float)(a[i].wct -a[i].dt);a[i].dczt=a[i].zt/a[i].st;}}printf("\t1 、按 id 号依次输出 \n");printf("\t2 、按完成顺序依次输出\n");printf("\n\t 请选择输出顺序:\t");scanf("%d",&px);printf("\nid ：到达时间 \t 服务时间 \t 完成时间 \t 周转时间 \t 带权周转时间 \n");sum1=0;sum2=0;switch(px){case 2:{for(i=0;i<n;i++){printf("%d ： %d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i].zt,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}printf("\n平均周转时间：%.2f\n",sum1/n);printf("\n平均带权周转时间：%.2f\n\n",sum2/n);break;}case 1:{for(j=0;j<n;j++){for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d ： %d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i].zt,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("\n平均周转时间：%.2f\n",sum1/n);printf("\n平均带权周转时间：%.2f\n\n",sum2/n);break;}default: break;}}void sjf(){int i,j,n,min,px;int b=0,z;float sum1,sum2;printf("\n\t\t 请输入有n 个进程 (0<n<=50):\t");scanf("%d/n",&n);while(n>50||n<=0){printf("n\t请重新输入：");scanf("%d",&n);}printf("\n");struct Gzuo{int id; // 进程名字int dt; // 到达时刻int st; // 服务时间int wct;// 完成时刻float zt;// 周转时间float dczt; // 带权周转时间};Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间：");scanf("%d",&a[i].dt);printf("\t服务时间：");scanf("%d",&a[i].st);printf("\n");}min=a[0].dt;for(j=n -1;j>=0;j --){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}if(a[i].dt==a[i+1].dt&&a[i].st>a[i+1].st){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}a[0].wct=a[0].st+a[0].dt;a[0].zt=(float)a[0].st;a[0].dczt=a[0].zt/a[0].st;for(i=1;i<n;i++){if(a[i].dt>a[0].wct) ;else b=b+1;}for(j=b -1;j>=1;j --){for(i=1;i<j;i++){if(a[i].st>a[i+1].st){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}for(i=1;i<n;i++){if(a[i].dt>a[i -1].wct){a[i].wct=a[i].dt+a[i].st;a[i].zt=(float)a[i].st;a[i].dczt=a[i].zt/a[i].st;}else{a[i].wct=a[i -1].wct+a[i].st;a[i].zt=(float)(a[i].wct -a[i].dt);a[i].dczt=a[i].zt/a[i].st;}for(j=i+1,b=j;j<n;j++){if(a[j].dt>a[i].wct) ;else b=b+1;}for(j=b -1;j>=i;j --){for(z=i;z<j;z++){if(a[z].st>a[z+1].st){min=a[z].dt;a[z].dt=a[z+1].dt;a[z+1].dt=min;min=a[z].st;a[z].st=a[z+1].st;a[z+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}}printf("\n\t 请选择输出顺序\n");printf("\t1 、按 id 号依次输出 \n");printf("\t2 、按完成顺序依次输出\n");scanf("%d",&px);printf("\nid ：到达时间 \t 服务时间 \t 完成时间 \t 周转时间 \t 带权周转时间\n"); sum1=0;sum2=0;switch(px){case 2:{for(i=0;i<n;i++){printf("%d ： %d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i].zt,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}printf("\n平均周转时间：%.2f\n",sum1/n);printf("\n平均带权周转时间：%.2f\n\n",sum2/n);break;}case 1:{for(j=0;j<n;j++){ for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d ： %d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i].zt,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("\n平均周转时间：%.2f\n",sum1/n);printf("\n平均带权周转时间：%.2f\n\n",sum2/n);break;}default: break;}}void yxj(){int i,j,n,min,px;int b=0,z;float sum1,sum2;printf("\n\t\t 请输入有n 个进程 (0<n<=50):\t");scanf("%d/n",&n);while(n>50||n<=0){printf("n\t请重新输入：");scanf("%d",&n);}printf("\n");struct Gzuo{int id;// 进程名字int dt;// 到达时刻int st;// 服务时间int yxj; // 优先级int wct;// 完成时刻float zt;// 周转时间float dczt; // 带权周转时间};Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间：");scanf("%d",&a[i].dt);printf("\t服务时间：");scanf("%d",&a[i].st);printf("\t优先级：");scanf("%d",&a[i].yxj);printf("\n");}min=a[0].dt;for(j=n -1;j>=0;j --){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;min=a[i].yxj;a[i].yxj=a[i+1].yxj;a[i+1].yxj=min;}if(a[i].dt==a[i+1].dt&&a[i].yxj<a[i+1].yxj){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;min=a[i].yxj;a[i].yxj=a[i+1].yxj;a[i+1].yxj=min;}}}a[0].wct=a[0].st+a[0].dt;a[0].zt=(float)a[0].st;a[0].dczt=a[0].zt/a[0].st;for(i=1;i<n;i++){if(a[i].dt>a[0].wct) ;else b++;}for(j=b -1;j>=1;j --){for(i=1;i<j;i++){if(a[i].yxj<a[i+1].yxj){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;min=a[i].yxj;a[i].yxj=a[i+1].yxj;a[i+1].yxj=min;}}}for(i=1;i<n;i++){if(a[i].dt>a[i -1].wct){a[i].wct=a[i].dt+a[i].st;a[i].zt=(float)a[i].st;a[i].dczt=a[i].zt/a[i].st;}else{a[i].wct=a[i -1].wct+a[i].st;a[i].zt=(float)(a[i].wct -a[i].dt);a[i].dczt=a[i].zt/a[i].st;}for(j=i+1,b=j;j<n;j++){if(a[j].dt>a[i].wct) ;else b=b+1;}for(j=b -1;j>=i;j --){for(z=i;z<j;z++){if(a[z].yxj<a[z+1].yxj){min=a[z].dt;a[z].dt=a[z+1].dt;a[z+1].dt=min;min=a[z].st;a[z].st=a[z+1].st;a[z+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}}printf("\n\t 请选择输出顺序\n");printf("\t1 、按 id 号依次输出 \n");printf("\t2 、按完成顺序依次输出\n");scanf("%d",&px);printf("\nid ：到达时间 \t 服务时间 \t 优先级 \t 完成时间 \t 周转时间 \t 带权周转时间 \n");sum1=0;sum2=0;switch(px){case 2:{for(i=0;i<n;i++){printf("%d ： %d\t\t%d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].yxj,a[i].st,a[i].wct,a[i].z t,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}printf("\n平均周转时间：%.2f\n",sum1/n);printf("\n平均带权周转时间：%.2f\n\n",sum2/n);break;}case 1:{for(j=0;j<n;j++){ for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d ： %d\t\t%d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].yxj,a[i].st,a[i].wct,a[i].z t,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("\n平均周转时间：%.2f\n",sum1/n);printf("\n平均带权周转时间：%.2f\n\n",sum2/n);break;}default: break;}}。

一、实验目的1. 理解进程的概念和进程状态转换。

2. 掌握进程同步与互斥的基本方法。

3. 学习使用信号量实现进程同步与互斥。

4. 熟悉进程调度算法。

二、实验环境1. 操作系统：Windows/Linux2. 编程语言：C/C++3. 开发工具：Visual Studio/Code::Blocks三、实验内容1. 进程状态转换2. 进程同步与互斥3. 信号量实现进程同步与互斥4. 进程调度算法四、实验步骤1. 进程状态转换```c#include <stdio.h>#include <unistd.h>void print_status(int state) {switch (state) {case 1: printf("创建状态\n"); break; case 2: printf("就绪状态\n"); break;case 3: printf("运行状态\n"); break; case 4: printf("阻塞状态\n"); break; case 5: printf("终止状态\n"); break; default: printf("未知状态\n"); break; }}int main() {int state = 1;print_status(state);sleep(1);state = 2;print_status(state);sleep(1);state = 3;print_status(state);sleep(1);state = 4;print_status(state);sleep(1);state = 5;print_status(state);return 0;}```2. 进程同步与互斥```c#include <stdio.h>#include <pthread.h>pthread_mutex_t lock;void thread_func(void arg) {pthread_mutex_lock(&lock);printf("线程 %d 进入临界区\n", (int )arg);sleep(2);printf("线程 %d 离开临界区\n", (int )arg);pthread_mutex_unlock(&lock);return NULL;}int main() {pthread_t tid1, tid2;int arg1 = 1, arg2 = 2;pthread_mutex_init(&lock, NULL);pthread_create(&tid1, NULL, thread_func, &arg1); pthread_create(&tid2, NULL, thread_func, &arg2); pthread_join(tid1, NULL);pthread_join(tid2, NULL);pthread_mutex_destroy(&lock);return 0;}```3. 信号量实现进程同步与互斥```c#include <stdio.h>#include <pthread.h>#include <semaphore.h>sem_t sem;void thread_func(void arg) {sem_wait(&sem);printf("线程 %d 进入临界区\n", (int )arg);sleep(2);printf("线程 %d 离开临界区\n", (int )arg);sem_post(&sem);return NULL;}int main() {pthread_t tid1, tid2;int arg1 = 1, arg2 = 2;sem_init(&sem, 0, 1);pthread_create(&tid1, NULL, thread_func, &arg1); pthread_create(&tid2, NULL, thread_func, &arg2);pthread_join(tid1, NULL);pthread_join(tid2, NULL);sem_destroy(&sem);return 0;}```4. 进程调度算法```c#include <stdio.h>#include <stdlib.h>#include <unistd.h>#define MAX_PROCESSES 5typedef struct {int pid;int arrival_time;int burst_time;int wait_time;int turnaround_time;} Process;int compare(const void a, const void b) {Process proc1 = (Process )a;Process proc2 = (Process )b;return proc1->arrival_time - proc2->arrival_time;}void fcfs(Process processes[], int n) {processes[0].wait_time = 0;processes[0].turnaround_time = processes[0].burst_time;for (int i = 1; i < n; i++) {processes[i].wait_time = processes[i - 1].turnaround_time + processes[i].arrival_time - processes[i].burst_time;processes[i].turnaround_time = processes[i].wait_time + processes[i].burst_time;}}int main() {Process processes[MAX_PROCESSES] = {{1, 0, 3, 0, 0},{2, 1, 6, 0, 0},{3, 4, 4, 0, 0},{4, 6, 5, 0, 0},{5, 8, 2, 0, 0}};qsort(processes, MAX_PROCESSES, sizeof(Process), compare);fcfs(processes, MAX_PROCESSES);for (int i = 0; i < MAX_PROCESSES; i++) {printf("PID: %d, Wait Time: %d, Turnaround Time: %d\n", processes[i].pid, processes[i].wait_time, processes[i].turnaround_time);}return 0;}```五、实验结果与分析通过以上实验，我们了解了进程状态转换、进程同步与互斥、信号量实现进程同步与互斥以及进程调度算法。

附1：实验三操作系统进程调度算法源代码#include"stdio.h"#include"stdlib.h"#include "string.h"#define WAIT 1#define RUN 2#define FINISH 3typedef struct pcb{char num;struct pcb *next;int priority;int timeneed;int state;}pcb;/*用此结构体来模拟一个进程*/struct pcb *head;struct pcb *run;pcb *jccreat(int n)/*此函数用于创建进程队列*/{int i=1;pcb *head,*p,*q;head=(pcb *)malloc(sizeof(pcb));/*创建一个空表头*/p=head;for(i=1;i<=n;i++)/*用循环来创建指定个结点*/{q=(pcb *)malloc(sizeof(pcb));p->next=q;printf("Input num,priority,timeneed:");scanf("%c,%d,%d\n",&q->num,&q->priority,&q->timeneed);q->state=WAIT;q->next=NULL;p=q;}return head;/*返回表头指针*/}pcb *getmaxpriority(struct pcb *head)/*此函数用来挑选一个优先级最大的进程来执行*/ {struct pcb *p,*q;int max;p=head->next;max=p->priority;/*初始max为队首结点的优先级*/q=p;while(p){if(p->priority>max)/*逐一比较，选出优先级最大的结点*/{max=p->priority;q=p;}p=p->next;}return q;}void delect(struct pcb *head,struct pcb *run)/*此函数用来将运行完的进程删除出进程队列*/{struct pcb *q=head;while(q->next)/*扫描进程队列，找到执行完了的进程*/{if(q->next->num==run->num)/*判断是不是已完成的进程*/{if(run->next!=NULL)q->next=run->next;else q->next=NULL;free(run);/*释放申请的空间*/return;}q=q->next;}}void control()/*此函数是用来控制各个进程的执行和调度*/{struct pcb *p;run=head->next;/*初始让第一个进程运行*/run->state=RUN;while(run){if(run->timeneed>0)/*如果当前run指针指向的进程所需时间不为零，状态为运行状态，就让这个进程运行*/if(run->state==RUN){printf("pcb %c is running.\n",run->num);printf("Waiting list:\n");/*显示整个等待队列*/printf("NUM PRIORITY TIMENEED STATE\n");p=head->next;while(p){if(p!=run)printf("%c %d %d %d\n",p->num,p->priority,p->timeneed ,p->state);p=p->next;}printf("\n");delay(10000000);/*模拟进程运行*/run->timeneed--;/*进程需要时间减一*/run->priority=run->priority-3;/*进程优先级减三*/}if(run->timeneed!=0){if(run->priority<=getmaxpriority(head)->priority)/*如果当前运行完的进程的优先级低于队列中优先级最高的进程*/{run->state=WAIT;run=getmaxpriority(head);/*从进程队列中挑选一个优先级最大的进程来运行*/run->state=RUN;}}else{ printf("pcb %c is finished.\n",run->num);delect(head,run);/*删除该结点*/if(head->next!=NULL)/*判断进程队列是不是为空*/{run=head->next;run->state=RUN;}else{printf("All progresses are done.\n");return;}}}}main(){int n;int flag=1;printf("Enter the number of the progresses:");scanf("%d",&n);/*输入要创建的进程的数量*/head=jccreat(n);/*创建进程队列，将链表的表头赋给head指针*/run=head->next;/*run指针指向正在运行的进程的pcb*/printf("********显示系统中所有进程PCB********\n");printf("NUM PRIORITY TIMENEED STATE\n");while(run){printf("%c %d %d %d\n",run->num,run->priority,run->ti meneed,run->state);run=run->next;} /*将刚创建的进程队列打印出来*/while(flag)/*由flag的值判断是否继续执行control()函数*/{if(head->next)/*判断进程是否完成*/control();else flag=0;}getch();}。

洛阳理工学院实验报告系别 计算机系 班级 学号 姓名课程名称 计算机操作系统实验日期 2015/10/11 实验名称 进程调度模拟算法 成绩实验目的：过本次实验，加深对进程概念的理解，进一步掌握进程状态的转变及进程调度策略。

一、实验条件：计算机一台，软件vc++6.0二、实验原理：设计程序模拟进程的时间片轮转法调度过程。

假设初始状态为：有ready个进程处于就绪状态，有blocked个进程处于阻塞状态。

采用轮转法进程调度算法进行调度(调度过程中，假设处于执行状态的进程不会阻塞)，且每过counter个时间片，唤醒处于阻塞队列队首的进程。

三、实验内容#include<stdio.h>#include<malloc.h>#define TRUE 1#define FALSE 0typedef struct PCB_type{char name; //进程名int state; //进程状态//2--表示"执行"状态//1--表示"就绪"状态//0--表示"阻塞"状态int cpu_time; //运行需要的CPU时间（需要运行的时间片个数） }PCBtype;typedef struct QueueNode //定义结点{PCBtype PCB;struct QueueNode *next;} LinkQueueNode;typedef struct Queue //定义队列{LinkQueueNode * head;LinkQueueNode * tail;} LinkQueue;LinkQueue rq,bq,runq;int deleteState=0;int ready=2;int blocked=3;int counter=5;int createq(LinkQueue *Q) //队列初始化{Q->head=(LinkQueueNode*)malloc(sizeof(LinkQueueNode));if(Q->head !=NULL){Q->tail=Q->head;Q->head->next=NULL;return (TRUE);}else return (FALSE);}void fuzhi(PCBtype *PCB1,PCBtype *PCB2){PCB1->name=PCB2->name;PCB1->state=PCB2->state;PCB1->cpu_time=PCB2->cpu_time;}int enterQueue(LinkQueue *Q,LinkQueueNode x) //入队列操作算法LinkQueueNode *NewNode;NewNode=(LinkQueueNode*)malloc(sizeof(LinkQueueNode));if(NewNode!=NULL){fuzhi(&NewNode->PCB,&x.PCB);NewNode->next=NULL;Q->tail->next=NewNode;Q->tail=NewNode;return (TRUE);}else return(FALSE);}LinkQueueNode * deleteQ(LinkQueue *Q){LinkQueueNode *NewNode;if(Q->head == Q->tail){deleteState =0;}else{NewNode = Q->head->next;Q->head->next = NewNode->next;if(Q->tail == NewNode)Q->tail = Q->head;deleteState =1;}return NewNode ;}void display(LinkQueue Q)LinkQueueNode *Newhead=Q.head->next;while(Newhead !=Q.tail->next){printf("**************\n");printf("该进程的名称为:%c\n",Newhead->);printf("该进程的状态为:%d\n",Newhead->PCB.state);printf("进程运行所需的CPU时间为:%d\n",Newhead->PCB.cpu_time);printf("**************\n");Newhead=Newhead->next;}}void create(){int a=13;LinkQueueNode *NewNode;PCBtype *pcbnode;NewNode=(LinkQueueNode *)malloc(sizeof(LinkQueueNode));pcbnode=(PCBtype *)malloc(sizeof(PCBtype));printf("请按序输入进程名,进程状态,运行所需时间片个数:\n");printf("\t 2-表示执行状态\n\t 1-表示就绪状态\n\t 0-表示阻塞状态\n");while(a==13){scanf("%c %d %d",&pcbnode->name,&pcbnode->cpu_time,&pcbnode->state );getchar();fuzhi(&NewNode->PCB,pcbnode);printf(" Enter继续输入,否则结束输入\n");a=getch();if(pcbnode->state==2)enterQueue(&runq,*NewNode);if(pcbnode->state==1)enterQueue(&rq,*NewNode);if(pcbnode->state==0)enterQueue(&bq,*NewNode);}display(rq);display(bq);}int GetStateQueue(LinkQueue Q){int retval;if(Q.head == Q.tail)retval=0;elseretval=1;return retval;}void dispath(){int counte=0,i=0,j;LinkQueueNode *deleteNode;int flag1,flag2;char name[20];while(TRUE){if(rq.head->next!=NULL||bq.head->next!=NULL){if(GetStateQueue(rq)){deleteNode=deleteQ(&rq);flag1 =enterQueue(&runq,*deleteNode);if(flag1){printf("进程%c调度成功,状态由就绪变成运行!\t",deleteNode->);deleteNode->PCB.state = 2;printf(" 进程状态变为:%d\n",deleteNode->PCB.state);deleteNode->PCB.cpu_time--;name[i++]=deleteNode->;}if(deleteNode->PCB.cpu_time>0){deleteNode->PCB.state= 1;flag1 =enterQueue(&rq,*deleteNode);if(flag1)printf("进程%c调度成功,状态由运行变成就绪!\t",deleteNode->);printf(" 进程状态变为:%d\n",deleteNode->PCB.state);}elsefree(deleteNode);}counte++;if(counte==counter){if(GetStateQueue(bq)){deleteNode = deleteQ(&bq);flag2 =enterQueue(&rq,*deleteNode);if(flag2)printf("进程%c调度成功,状态由阻塞变成就绪!\t",deleteNode->);deleteNode->PCB.state=1;printf(" 进程状态变为:%d\n",deleteNode->PCB.state);counte=0;}}}else break;}printf("执行序列为：\n");for(j=0;j<i;j++){printf("%c",name[j]);}printf("\n");}void main(){if(createq(&rq)&&createq(&bq)&&createq(&runq))printf("\t队列初始化成功!\n");else{printf("队列初始化失败,程序将退出\n!");exit(0);}create();dispath();}四、原始数据纪录：①输入数据：进程需要的cpu时间是指需要几个时间片，进程状态0代表阻塞，1代表就绪，2代表执行。

一、实验目的本次实验旨在通过模拟进程调度过程，加深对进程调度算法的理解，并掌握进程调度程序的设计与实现方法。

实验内容主要包括：创建进程、进程调度、进程执行、进程结束等。

二、实验环境操作系统：Linux编程语言：C/C++三、实验内容1. 进程调度算法本实验采用三种进程调度算法：FIFO（先进先出）、时间片轮转法、多级反馈队列调度算法。

2. 进程调度程序设计进程调度程序主要由以下部分组成：（1）进程控制块（PCB）PCB用于描述进程的基本信息，包括进程名、到达时间、需要运行时间、已运行时间、进程状态等。

（2）就绪队列就绪队列用于存储处于就绪状态的进程，按照进程的优先级或到达时间进行排序。

（3）进程调度函数进程调度函数负责从就绪队列中选择一个进程进行执行，并将CPU分配给该进程。

（4）进程执行函数进程执行函数负责模拟进程的执行过程，包括进程的创建、执行、结束等。

四、实验源码```c#include <stdio.h>#include <stdlib.h>#include <time.h>#define MAX_PROCESSES 10typedef struct PCB {int pid;int arrival_time;int need_time;int used_time;int priority;int state; // 0: 等待 1: 运行 2: 完成} PCB;PCB processes[MAX_PROCESSES];int process_count = 0;typedef struct Queue {PCB queue;int front;int rear;int size;} Queue;Queue ready_queue;void init_queue(Queue q) {q->queue = (PCB )malloc(sizeof(PCB) MAX_PROCESSES); q->front = q->rear = 0;q->size = 0;}void enqueue(Queue q, PCB p) {if (q->size == MAX_PROCESSES) {printf("Queue is full.\n");return;}q->queue[q->rear] = p;q->rear = (q->rear + 1) % MAX_PROCESSES; q->size++;}PCB dequeue(Queue q) {if (q->size == 0) {printf("Queue is empty.\n");return NULL;}PCB p = &q->queue[q->front];q->front = (q->front + 1) % MAX_PROCESSES; q->size--;return p;}int is_empty(Queue q) {return q->size == 0;}void print_queue(Queue q) {printf("Queue: ");for (int i = 0; i < q->size; i++) {PCB p = &q->queue[(q->front + i) % MAX_PROCESSES];printf("PID: %d, Arrival Time: %d, Need Time: %d, Used Time: %d, Priority: %d, State: %d\n",p->pid, p->arrival_time, p->need_time, p->used_time, p->priority, p->state);}}void init_processes() {for (int i = 0; i < MAX_PROCESSES; i++) {processes[i].pid = i;processes[i].arrival_time = rand() % 10;processes[i].need_time = rand() % 10 + 1;processes[i].used_time = 0;processes[i].priority = rand() % 3;processes[i].state = 0;}}void schedule() {int time = 0;while (process_count > 0) {for (int i = 0; i < process_count; i++) {PCB p = &processes[i];if (p->arrival_time == time) {enqueue(&ready_queue, p);p->state = 1;}}if (!is_empty(&ready_queue)) {PCB p = dequeue(&ready_queue);p->used_time++;printf("Process %d is running.\n", p->pid);if (p->used_time == p->need_time) {p->state = 2;printf("Process %d is finished.\n", p->pid); }}time++;}}int main() {srand(time(NULL));init_queue(&ready_queue);init_processes();process_count = rand() % MAX_PROCESSES + 1;schedule();print_queue(&ready_queue);return 0;}```五、实验结果与分析1. FIFO调度算法实验结果表明，FIFO调度算法按照进程的到达时间进行调度，可能导致短作业等待时间长，效率较低。