进程调度算法实验报告doc

实验报告课程名称操作系统实验名称进程调度算法设计与实现姓名学号专业班级实验日期成绩指导教师(①实验目的②实验设备和环境③实验内容与步骤④实验结果与分析⑤总结,问题及建议）一、内容：设计一个简单的进程调度算法，模拟OS中的进程调度过程二、要求：①进程数不少于5个；②进程调度算法任选;最好选用动态优先数法，每运行一个时间片优先数减3③用C++（或C）语言编程；④程序运行时显示进程调度过程。

三、步骤:①设计PCB及其数据结构：进程标识数：ID进程优先数：PRIORITY（优先数越大，优先级越高）进程已占用时间片：CPUTIME进程尚需时间片:ALLTIME（一旦运行完毕,ALLTIME为0）进程队列指针：NEXT,用来将PCB排成队列进程状态：STATE(一般为就绪，不用）②设计进程就绪队列及数据结构；③设计进程调度算法,并画出程序流程图;④设计输入数据和输出格式;结构格式：当前正运行的进程:0当前就绪队列:2，1，3,4⑤编程上机，验证结果。

四、分析假设调度前，系统中有5个进程，其初始状态如下：①以时间片为单位调度运行；②每次总是从ALLTIME中不为0，且PRIORITY最大的进程调度运行一个时间片；③上述进程运行后其优先数减3，再修改其CPUTIME和ALLTIME，重复②，③④直到所有进程的ALLTIME均变为0。

五、代码＃include〈iostream〉＃include〈string〉#include<queue〉using namespace std;typedef struct pcb ｛string pName;//进程名int priorityNumber；//优先数float serviceTime；//服务时间float estimatedRunningtime;//估计运行时间char state；//状态bool operator〈(const struct pcb ＆a)const {return priorityNumber > a。

实验一、进程调度实验报告一、实验目的进程调度是操作系统中的核心功能之一，其目的是合理地分配 CPU 资源给各个进程，以提高系统的整体性能和资源利用率。

通过本次实验，我们旨在深入理解进程调度的原理和算法，掌握进程状态的转换，观察不同调度策略对系统性能的影响，并通过实际编程实现来提高我们的编程能力和对操作系统概念的理解。

二、实验环境本次实验使用的操作系统为 Windows 10，编程语言为 C+＋，开发工具为 Visual Studio 2019。

三、实验原理1、进程状态进程在其生命周期中会经历不同的状态，包括就绪态、运行态和阻塞态。

就绪态表示进程已经准备好执行，只等待 CPU 分配；运行态表示进程正在 CPU 上执行；阻塞态表示进程由于等待某个事件（如 I/O操作完成）而暂时无法执行。

2、调度算法常见的进程调度算法有先来先服务（FCFS）、短作业优先（SJF）、时间片轮转（RR）等。

先来先服务算法按照进程到达的先后顺序进行调度。

短作业优先算法优先调度执行时间短的进程。

时间片轮转算法将 CPU 时间划分成固定大小的时间片，每个进程轮流获得一个时间片执行。

四、实验内容1、设计并实现一个简单的进程调度模拟器定义进程结构体，包含进程 ID、到达时间、执行时间、剩余时间等信息。

实现进程的创建、插入、删除等操作。

实现不同的调度算法。

2、对不同调度算法进行性能测试生成一组具有不同到达时间和执行时间的进程。

分别采用先来先服务、短作业优先和时间片轮转算法进行调度。

记录每个算法下的平均周转时间、平均等待时间等性能指标。

五、实验步骤1、进程结构体的定义｀｀｀c+＋struct Process ｛int pid;int arrivalTime;int executionTime;int remainingTime;int finishTime;int waitingTime;int turnaroundTime;｝；｀｀｀2、进程创建函数｀｀｀c+＋void createProcess(Process processes, int& numProcesses, int pid, int arrivalTime, int executionTime) ｛processesnumProcessespid ＝ pid;processesnumProcessesarrivalTime ＝ arrivalTime;processesnumProcessesexecutionTime ＝ executionTime;processesnumProcessesremainingTime ＝ executionTime;numProcesses+＋；｝｀｀｀3、先来先服务调度算法实现｀｀｀c+＋void fcfsScheduling(Process processes, int numProcesses) ｛int currentTime ＝ 0;for （int i ＝ 0; i ＜ numProcesses; i+＋）｛if （currentTime ＜ processesiarrivalTime) ｛currentTime ＝ processesiarrivalTime;｝processesistartTime ＝ currentTime;currentTime ＋＝ processesiexecutionTime;processesifinishTime ＝ currentTime;processesiwaitingTime ＝ processesistartTime processesiarrivalTime;processesiturnaroundTime ＝ processesifinishTime processesiarrivalTime;｝｝｀｀｀4、短作业优先调度算法实现｀｀｀c+＋void sjfScheduling(Process processes, int numProcesses) ｛int currentTime ＝ 0;int minExecutionTime, selectedProcess;bool found;while （true) ｛found ＝ false;minExecutionTime ＝ INT_MAX;selectedProcess ＝－1;for （int i ＝ 0; i ＜ numProcesses; i+＋）｛if （processesiarrivalTime ＜＝ currentTime ＆＆processesiremainingTime ＜ minExecutionTime ＆＆processesiremainingTime ＞ 0) ｛found ＝ true;minExecutionTime ＝ processesiremainingTime;selectedProcess ＝ i;｝｝if （！found) ｛break;｝processesselectedProcessstartTime ＝ currentTime;currentTime ＋＝ processesselectedProcessremainingTime;processesselectedProcessfinishTime ＝ currentTime;processesselectedProcesswaitingTime ＝processesselectedProcessstartTime processesselectedProcessarrivalTime;processesselectedProcessturnaroundTime ＝processesselectedProcessfinishTime processesselectedProcessarrivalTime;processesselectedProcessremainingTime ＝ 0;｝｝｀｀｀5、时间片轮转调度算法实现｀｀｀c+＋void rrScheduling(Process processes, int numProcesses, int timeSlice) ｛int currentTime ＝ 0;Queue<int> readyQueue;for （int i ＝ 0; i ＜ numProcesses; i+＋）｛readyQueueenqueue(i)；｝while （！readyQueueisEmpty(））｛int currentProcess ＝ readyQueuedequeue(）；if （processescurrentProcessarrivalTime ＞ currentTime) ｛currentTime ＝ processescurrentProcessarrivalTime;｝if （processescurrentProcessremainingTime ＜＝ timeSlice) ｛currentTime ＋＝ processescurrentProcessremainingTime;processescurrentProcessfinishTime ＝ currentTime;processescurrentProcesswaitingTime ＝processescurrentProcessstartTime processescurrentProcessarrivalTime;processescurrentProcessturnaroundTime ＝processescurrentProcessfinishTime processescurrentProcessarrivalTime;processescurrentProcessremainingTime ＝ 0;｝ else ｛currentTime ＋＝ timeSlice;processescurrentProcessremainingTime ＝ timeSlice;readyQueueenqueue(currentProcess)；｝｝｝｀｀｀6、性能指标计算函数｀｀｀c+＋void calculatePerformanceMetrics(Process processes, int numProcesses, double& averageWaitingTime, double& averageTurnaroundTime) ｛double totalWaitingTime ＝ 0, totalTurnaroundTime ＝ 0;for （int i ＝ 0; i ＜ numProcesses; i+＋）｛totalWaitingTime ＋＝ processesiwaitingTime;totalTurnaroundTime ＋＝ processesiturnaroundTime;｝averageWaitingTime ＝ totalWaitingTime ／ numProcesses; averageTurnaroundTime ＝ totalTurnaroundTime ／ numProcesses;｝｀｀｀7、主函数｀｀｀c+＋int main(）｛Process processes100;int numProcesses ＝ 0;／／创建进程createProcess(processes, numProcesses, 1, 0, 5)；createProcess(processes, numProcesses, 2, 1, 3)；createProcess(processes, numProcesses, 3, 2, 4)；createProcess(processes, numProcesses, 4, 3, 2)；／／先来先服务调度fcfsScheduling(processes, numProcesses)；double fcfsAverageWaitingTime, fcfsAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, fcfsAverageWaitingTime, fcfsAverageTurnaroundTime)；cout ＜＜＂先来先服务调度的平均等待时间：＂＜＜fcfsAverageWaitingTime ＜＜ endl;cout ＜＜＂先来先服务调度的平均周转时间：＂＜＜fcfsAverageTurnaroundTime ＜＜ endl;／／短作业优先调度sjfScheduling(processes, numProcesses)；double sjfAverageWaitingTime, sjfAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, sjfAverageWaitingTime, sjfAverageTurnaroundTime)；cout ＜＜＂短作业优先调度的平均等待时间：＂＜＜sjfAverageWaitingTime ＜＜ endl;cout ＜＜＂短作业优先调度的平均周转时间：＂＜＜sjfAverageTurnaroundTime ＜＜ endl;／／时间片轮转调度（时间片为 2）rrScheduling(processes, numProcesses, 2)；double rrAverageWaitingTime, rrAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, rrAverageWaitingTime, rrAverageTurnaroundTime)；cout ＜＜＂时间片轮转调度（时间片为 2）的平均等待时间：＂＜＜ rrAverageWaitingTime ＜＜ endl;cout ＜＜＂时间片轮转调度（时间片为 2）的平均周转时间：＂＜＜ rrAverageTurnaroundTime ＜＜ endl;return 0;｝｀｀｀六、实验结果与分析1、先来先服务调度平均等待时间：40平均周转时间：85分析：先来先服务调度算法简单直观，但对于短作业可能会造成较长的等待时间，导致平均等待时间和平均周转时间较长。

实验报告实验一：进程调度算法一、实验目的1．利用高级语言实现三种不同及进程调度算法：短作业优先算法、时间片轮转调度算法和优先级调度算法。

2．通过实验理解有关进程控制块，进程队列等的概念。

二、实验原理各调度算法思想：1.先来先服务算法(FCFS)：按照进程进入就绪队列的先后次序来分配CPU，一旦一个进程占有CPU，就一直运行下去，知道该进程完成工作，才释放CPU。

2.时间片轮转算法:系统将所有就绪进程按到达时间的先后次序排成一个队列，进程调度程序总是选择队列中的第一个进程执行，且仅能执行一个时间片，在使用完一个时间片后，即使进程并未完成其运行，也必须将CPU交给下一个进程；如果一个时间片未使用完就完成了该进程，则剩下的时间分配给下一个进程。

3.优先权调度算法；在创建进程时就确定优先权，确定之后在整个程序运行期间不再改变，根据优先级排列，系统会把CPU分配给优先权最高的进程。

三、实验步骤、数据记录及处理1、算法流程抽象数据类型的定义：PCB块结构体类型struct PCB{int name;int arrivetime; // 到达时间int servicetime; // 服务时间//int starttime[max]; // 开始时间int finishtime; // 完成/ 结束时间int turntime; // 周转时间int average_turntime; // 带权周转时间int sign; // 标志进程是否完成int remain_time; // 剩余时间int priority; // 优先级}pcb[max];主程序的流程以及各程序模块之间的层次( 调用) 关系：主程序中从键盘得到进程的数量，创建PCB，调用layout ()函数显示选择界面。

Layout ()函数中选择相应的算法并调用相关函数如：FCFS()、time_segment(); Priority() ，这三个函数分别实现先来先服务算法，时间片轮转算法和优先级算法，最后分别打印。

进程调度算法实验报告进程调度算法实验报告一、引言进程调度算法是操作系统中的重要组成部分，它决定了进程在CPU上的执行顺序。

合理的进程调度算法能够提高系统的性能和效率，使得多个进程能够公平地共享CPU资源。

本实验旨在通过实际操作和数据分析，探究不同的进程调度算法对系统性能的影响。

二、实验方法1. 实验环境本次实验使用了一台配置较高的计算机作为实验环境，操作系统为Windows 10。

实验中使用了C语言编写的模拟进程调度程序。

2. 实验步骤（1）编写模拟进程调度程序，实现常见的进程调度算法，包括先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转（RR）和优先级调度（Priority）。

（2）设计一组测试用例，包括不同执行时间的进程和不同优先级的进程。

（3）运行模拟进程调度程序，记录每个进程的等待时间、周转时间和响应时间。

（4）根据实验结果分析不同进程调度算法的性能差异。

三、实验结果与分析1. 先来先服务（FCFS）调度算法先来先服务调度算法按照进程到达的先后顺序进行调度，即先到达的进程先执行。

实验结果显示，该算法对于执行时间较短的进程表现良好，但对于执行时间较长的进程则存在明显的不公平性。

长作业的等待时间较长，导致整体执行效率较低。

2. 最短作业优先（SJF）调度算法最短作业优先调度算法按照进程执行时间的长度进行调度，即执行时间最短的进程先执行。

实验结果显示，该算法能够最大程度地减少平均等待时间和周转时间，提高系统的执行效率。

然而，该算法对于执行时间较长的进程存在饥饿问题，即长作业可能一直等待短作业的执行，导致长作业的等待时间过长。

3. 时间片轮转（RR）调度算法时间片轮转调度算法将CPU的执行时间划分为固定长度的时间片，每个进程按照轮流执行的方式进行调度。

实验结果显示，该算法能够保证每个进程都能够获得一定的执行时间，提高了系统的公平性。

然而，对于执行时间较长的进程而言，由于需要等待其他进程的轮转，其执行效率相对较低。

进程调度实验报告一、实验目的。

本实验旨在通过对进程调度算法的模拟和实验，加深学生对进程调度原理的理解，掌握各种进程调度算法的特点和应用场景，提高学生的实际操作能力和分析问题的能力。

二、实验环境。

本次实验使用了C语言编程语言，通过模拟实现了先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转（RR）和多级反馈队列（MFQ）四种进程调度算法。

三、实验过程。

1. 先来先服务（FCFS）调度算法。

先来先服务调度算法是一种非抢占式的调度算法，按照进程到达的先后顺序进行调度。

在本次实验中，我们通过模拟多个进程到达并排队等待CPU执行，观察其平均等待时间和平均周转时间。

实验结果表明，先来先服务调度算法适用于作业长度差异较大的情况，但容易产生“饥饿”现象。

2. 最短作业优先（SJF）调度算法。

最短作业优先调度算法是一种非抢占式的调度算法，按照作业执行时间的长短进行调度。

在本次实验中，我们通过模拟多个作业的执行时间，观察其平均等待时间和平均周转时间。

实验结果表明，最短作业优先调度算法能够最大程度地减少平均等待时间，但可能会导致长作业被“饿死”。

3. 时间片轮转（RR）调度算法。

时间片轮转调度算法是一种抢占式的调度算法，每个进程被分配一个时间片，当时间片用完后，该进程被放到队尾等待。

在本次实验中，我们通过模拟多个进程的执行和时间片的调度，观察其平均等待时间和平均周转时间。

实验结果表明，时间片轮转调度算法能够保证每个进程都能得到一定的执行时间，但可能会导致上下文切换频繁。

4. 多级反馈队列（MFQ）调度算法。

多级反馈队列调度算法是一种综合性的调度算法，根据进程的优先级和执行时间进行动态调整。

在本次实验中，我们通过模拟多个进程的执行和不同优先级队列的调度，观察其平均等待时间和平均周转时间。

实验结果表明，多级反馈队列调度算法能够兼顾短作业和长作业，提高了系统的整体性能。

四、实验总结。

通过本次实验，我们深入理解了不同进程调度算法的特点和适用场景。

计算机操作系统实验报告实验二进程调度算法一、实验名称：进程调度算法二、实验内容：编程实现如下算法：1.先来先服务算法；2.短进程优先算法；3.时间片轮转调度算法。

三、问题分析与设计：1.先来先服务调度算法先来先服务调度算法是一种最简单的调度算法，该算法既可以用于作业调度，也可用于进程调度。

当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将他们调入内存，为它们分配资源、创建进程，然后放入就绪队列。

在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。

该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。

FCFS算法比较有利于长作业（进程），2.短作业（进程）优先调度算法短作业（进程）优先调度算法SJ（P）F，是指对短作业或短进程优先调度的算法。

它们可以分别用于作业调度和进程调度。

短作业优先（SJF）的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。

而短进程（SPF）调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机再重新调度。

SJ(P)F调度算法能有效地降低作业（进程）的平均等待时间，提高系统吞吐量。

该算法对长作业不利，完全未考虑作业的紧迫程度。

3.时间片轮转算法在时间片轮转算法中，系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。

当执行的时间片用完时，由一个计数器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。

这样就可以保证就绪队列中的所有进程在一给定的时间内均能获得一时间片的处理机执行时间。

换言之，系统能在给定的时间内响应所有用户的请求。

【精品】进程调度算法模拟实验报告一、实验目的本实验通过模拟进程的调度算法，使学生掌握多种进程调度算法的实现过程及其优缺点。

二、实验内容本实验实现了三种进程调度算法：先来先服务（First Come First Served，FCFS）、最短作业优先（Shortest Job First，SJF）、时间片轮转（Round Robin，RR）。

（一）FCFS算法FCFS算法是一种非抢占式的进程调度算法，按照进程到达的先后顺序进行执行，即先到达的进程先被执行，后到达的进程后被执行。

当一个进程在执行过程中发生等待时，其他新到达的进程会继续执行。

等待时间长的进程会长时间等待，造成了响应时间长的问题。

SJF算法是一种动态优先级的进程调度算法，按照进程预计运行时间的大小来决定其优先级，预计运行时间短的进程具有高优先级。

当一个新进程到达时，如果其预计运行时间比当前正在运行的所有进程都短，那么这个新进程就可以立即执行。

该算法在保证短作业优先的同时，可能会导致长作业饥饿的问题。

（三）RR算法RR算法是一种抢占式的进程调度算法，每个进程被分配一个时间片，当一个进程的时间片用完时，就被剥夺CPU，然后排到队列的末尾，等待下一次调度。

该算法能够保证每个进程的响应时间比较短，但可能会导致CPU利用率较低。

三、实验步骤（一）编写程序框架首先，根据实验要求，编写完整的程序框架，包括进程类Process和调度器类Scheduler。

Process类中包含了进程需要的属性和方法，如进程ID、进程到达时间、进程执行时间、进程状态等。

Scheduler类中包含了进程调度所需要的方法，如FCFS、SJF、RR 调度算法等。

（二）实现进程调度算法FCFS算法较为简单，只需要按照进程到达时间排序即可。

```pythondef FCFS(self):queue = Queue()process_time = 0while not self.is_finished():ready_process = self.get_arrived_process(process_time)if ready_process:queue.put(ready_process)if not queue.empty():current_process = queue.get()current_process.status = 'running'current_process.start_time = process_timecurrent_process.end_time = current_process.start_time + current_process.run_timeself.finished_processes.append(current_process)process_time += 1```2. SJF算法SJF算法需要进行进程预计运行时间的排序，然后按照排序后的顺序进行执行。

一、实验目的1. 加深对进程概念和进程调度算法的理解。

2. 掌握进程调度算法的基本原理和实现方法。

3. 培养编程能力和系统分析能力。

二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 2019三、实验内容1. 实现进程调度算法2. 创建进程控制块（PCB）3. 模拟进程调度过程四、实验原理进程调度是操作系统核心功能之一，负责将CPU分配给就绪队列中的进程。

常见的进程调度算法有先来先服务（FCFS）、短作业优先（SJF）、优先级调度、时间片轮转（RR）等。

1. 先来先服务（FCFS）算法：按照进程到达就绪队列的顺序进行调度。

2. 短作业优先（SJF）算法：优先调度运行时间最短的进程。

3. 优先级调度算法：根据进程的优先级进行调度，优先级高的进程优先执行。

4. 时间片轮转（RR）算法：每个进程分配一个时间片，按顺序轮流执行，时间片结束后进行调度。

五、实验步骤1. 定义进程控制块（PCB）结构体，包含进程名、到达时间、运行时间、优先级、状态等信息。

2. 创建进程队列，用于存储就绪队列、等待队列和完成队列。

3. 实现进程调度算法：a. FCFS算法：按照进程到达就绪队列的顺序进行调度。

b. SJF算法：优先调度运行时间最短的进程。

c. 优先级调度算法：根据进程的优先级进行调度。

d. 时间片轮转（RR）算法：每个进程分配一个时间片，按顺序轮流执行。

4. 模拟进程调度过程：a. 初始化进程队列，将进程添加到就绪队列。

b. 循环执行调度算法，将CPU分配给就绪队列中的进程。

c. 更新进程状态，统计进程执行时间、等待时间等指标。

d. 当进程完成时，将其移至完成队列。

六、实验结果与分析1. FCFS算法：按照进程到达就绪队列的顺序进行调度，简单易实现，但可能导致短作业等待时间过长。

2. SJF算法：优先调度运行时间最短的进程，能提高系统吞吐量，但可能导致进程饥饿。

第1篇一、实验目的通过本次实验，加深对操作系统进程调度原理的理解，掌握先来先服务（FCFS）、时间片轮转（RR）和动态优先级（DP）三种常见调度算法的实现，并能够分析这些算法的优缺点，提高程序设计能力。

二、实验环境- 编程语言：C语言- 操作系统：Linux- 编译器：GCC三、实验内容本实验主要实现以下内容：1. 定义进程控制块（PCB）结构体，包含进程名、到达时间、服务时间、优先级、状态等信息。

2. 实现三种调度算法：FCFS、RR和DP。

3. 创建一个进程队列，用于存储所有进程。

4. 实现调度函数，根据所选算法选择下一个执行的进程。

5. 模拟进程执行过程，打印进程执行状态和就绪队列。

四、实验步骤1. 定义PCB结构体：```ctypedef struct PCB {char processName[10];int arrivalTime;int serviceTime;int priority;int usedTime;int state; // 0: 等待，1: 运行，2: 完成} PCB;```2. 创建进程队列：```cPCB processes[MAX_PROCESSES]; // 假设最多有MAX_PROCESSES个进程int processCount = 0; // 实际进程数量```3. 实现三种调度算法：（1）FCFS调度算法：```cvoid fcfsScheduling() {int i, j;for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程：%s\n", processes[i].processName); processes[i].usedTime++;if (processes[i].usedTime == processes[i].serviceTime) { processes[i].state = 2; // 设置为完成状态printf("进程：%s 完成\n", processes[i].processName); }for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```（2）RR调度算法：```cvoid rrScheduling() {int i, j, quantum = 1; // 时间片for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程：%s\n", processes[i].processName); processes[i].usedTime++;processes[i].serviceTime--;if (processes[i].serviceTime <= 0) {processes[i].state = 2; // 设置为完成状态printf("进程：%s 完成\n", processes[i].processName); } else {processes[i].arrivalTime++;}for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```（3）DP调度算法：```cvoid dpScheduling() {int i, j, minPriority = MAX_PRIORITY;int minIndex = -1;for (i = 0; i < processCount; i++) {if (processes[i].arrivalTime <= 0 && processes[i].priority < minPriority) {minPriority = processes[i].priority;minIndex = i;}}if (minIndex != -1) {processes[minIndex].state = 1; // 设置为运行状态printf("正在运行进程：%s\n", processes[minIndex].processName);processes[minIndex].usedTime++;processes[minIndex].priority--;processes[minIndex].serviceTime--;if (processes[minIndex].serviceTime <= 0) {processes[minIndex].state = 2; // 设置为完成状态printf("进程：%s 完成\n", processes[minIndex].processName); }}}```4. 模拟进程执行过程：```cvoid simulateProcess() {printf("请选择调度算法（1：FCFS，2：RR，3：DP）：");int choice;scanf("%d", &choice);switch (choice) {case 1:fcfsScheduling();break;case 2:rrScheduling();break;case 3:dpScheduling();break;default:printf("无效的调度算法选择。

操作系统教程——进程调度算法院系计算机与软件学院班级08软件工程2班学号20081344066姓名何丽茗进程调度算法的模拟实现⏹实验目的1．本实验模拟在单处理机情况下的处理机调度问题，加深对进程调度的理解。

2．利用程序设计语言编写算法，模拟实现先到先服务算法FCFS、轮转调度算法RR、最短作业优先算法SJF、优先级调度算法PRIOR、最短剩余时间优先算法SRTF。

3．进行算法评价，计算平均等待时间和平均周转时间。

⏹实验内容及结果1．先来先服务算法2．轮转调度算法3. 优先级调度算法4. 最短时间优先算法5. 最短剩余时间优先算法实验总结在此次模拟过程中，将SRTF单独拿了出来用指针表示，而其余均用数组表示。

完整代码【Srtf.cpp代码如下：】//最短剩余时间优先算法的实现#include<stdio.h>#include<stdlib.h>#include<time.h>typedef struct{int remain_time; //进程剩余执行时间int arrive_time; //进程到达时间int Tp; //进入就绪队列的时间int Tc; //进入执行队列的时间int To; //进程执行结束的时间int number; //进程编号}Process_Block; //定义进程模块typedef struct _Queue{Process_Block PB;struct _Queue *next;}_Block,*Process; //定义一个进程模块队列中结点typedef struct{Process head; //队列头指针Process end; //队列尾指针}Process_Queue; //进程队列Process_Queue PQ; //定义一个全局队列变量int t; //全局时间Process Run_Now; //当前正在运行的进程，作为全局变量void InitQueue(Process_Queue PQ){PQ.head ->next = NULL;PQ.end ->next = PQ.head;}/*初始化队列*/int IsEmpty(Process_Queue PQ){if(PQ.end->next == PQ.head)return 1; //队列空的条件为头指针指向尾指针并且尾指针指向头指针return 0;}/*判定队列是否为空队列*/void EnQueue(Process_Queue PQ,Process P){Process temp =(Process)malloc(sizeof(_Block));temp = PQ.end;temp->next->next = P;PQ.end->next = P;}/*插入队列操作*/Process DeQueue(Process_Queue PQ){if(IsEmpty(PQ))return NULL;Process temp = PQ.head->next;PQ.head->next= temp ->next;if(PQ.end->next == temp)PQ.end->next = PQ.head;return temp;}/*出列操作*/Process ShortestProcess(Process_Queue PQ){if(IsEmpty(PQ)) //如果队列为空，返回{if(!Run_Now)return NULL;elsereturn Run_Now;}Process temp,shortest,prev;int min_time;if(Run_Now) //如果当前有进程正在执行，{shortest = Run_Now; //那么最短进程初始化为当前正在执行的进程，min_time = Run_Now->PB.remain_time;}else//如果当前没有进程执行，{shortest = PQ.head->next; //则最短进程初始化为队列中第一个进程min_time = PQ.head->next->PB.remain_time;}temp = PQ.head;prev = temp;while(temp->next)if(temp->next->PB.remain_time <min_time) //如果当前进程的剩余时间比min_time短，{shortest = temp->next; //则保存当前进程，min_time = shortest->PB.remain_time;prev=temp; //及其前驱}temp=temp->next;}if(shortest == PQ.end->next) //如果最短剩余时间进程是队列中最后一个进程，PQ.end->next = prev; //则需要修改尾指针指向其前驱prev->next = shortest->next; //修改指针将最短剩余时间进程插入到队头return shortest;}/*调度最短剩余时间的进程至队头*/void Run(){Run_Now->PB.remain_time--; //某一时间运行它的剩余时间减return;}/*运行函数*/void Wait(){return ;}int sum(int array[],int n){int i,sum=0;for(i=0;i<n;i++)sum+=array[i];return sum;}int main(){PQ.head = (Process)malloc(sizeof(_Block));PQ.end = (Process)malloc(sizeof(_Block));Run_Now = (Process)malloc(sizeof(_Block));Run_Now =NULL;InitQueue(PQ);int i,N,Total_Time=0; //Total_Time为所有进程的执行时间之和printf("请输入计算机中的进程数目:\n");scanf("%d",&N);Process *P,temp;P = (Process*)malloc(N*sizeof(Process));int *wt,*circle_t;wt =(int*)malloc(N*sizeof(int));circle_t =(int*)malloc(N*sizeof(int));for(i=0;i<N;i++){P[i] = (Process)malloc(sizeof(_Block));P[i]->PB.number =i+1;P[i]->next =NULL;wt[i] =0;circle_t[i] =0;printf("输入第%d个进程的到达时间及剩余执行时间:\n",i+1);scanf("%d %d",&P[i]->PB.arrive_time,&P[i]->PB.remain_time);}for(i=0;i<N;i++)Total_Time+=P[i]->PB.remain_time;printf("\n进程按顺序运行依次为:\n");i=0;int k=0;for(t=0;;t++){if(Run_Now) //如果当前有进程正在执行{Run();if(t == P[i]->PB.arrive_time) //如果当前时间正好有进程进入{if(P[i]->PB.remain_time < Run_Now->PB.remain_time){temp = P[i];P[i] = Run_Now;Run_Now = temp; //则调度它至运行队列中，Run_Now->PB.Tp=t;Run_Now->PB.Tc=t;wt[Run_Now->PB.number-1]+=Run_Now->PB.Tc-Run_Now->PB.Tp;printf("%d ",Run_Now->PB.number);}EnQueue(PQ,P[i]); //并将当前运行进程重新插入队列中P[i]->PB.Tp=t;k++;i=(i+1)>(N-1)?(N-1):(i+1);}if(Run_Now->PB.remain_time == 0) //如果当前进程运行结束，{Run_Now->PB.To=t; //进程运行结束的时间circle_t[Run_Now->PB.number-1] +=t-Run_Now->PB.arrive_time;free(Run_Now); //则将它所占资源释放掉，Run_Now =NULL; //并修改Run_Now为NULLRun_Now = ShortestProcess(PQ); //从就绪队列中调出最短剩余时间进程至队头，if(!Run_Now) //如果队列为空，转为等待状态{if(IsEmpty(PQ) && k >= N) break;Wait();continue;}else{Run_Now->PB.Tc=t;wt[Run_Now->PB.number-1]+=Run_Now->PB.Tc-Run_Now->PB.Tp;printf("%d ",Run_Now->PB.number);}}}else//如果当前运行进程为空，那么{if(t == P[i]->PB.arrive_time) //如果正好这时有进程入队{k++;EnQueue(PQ,P[i]);Run_Now = DeQueue(PQ); //则直接被调入运行队列中Run_Now->PB.Tp=t;Run_Now->PB.Tc=t;printf("%d ",Run_Now->PB.number);i=(i+1)>(N-1)?(N-1):(i+1);}else{Wait();continue;}}}printf("\n");printf("平均等待时间是:\n%f\n",((float)sum(wt,N))/N);printf("平均周转时间是:\n%f\n",((float)sum(circle_t,N))/N);return 0;}//////////////////////////////////////////////////////【Process.cpp代码如下：】#include<iostream>#include<string>using namespace std;class Process{public:string ProcessName; // 进程名字int Time; // 进程需要时间int leval; // 进程优先级int LeftTime; // 进程运行一段时间后还需要的时间};void Copy ( Process proc1, Process proc2); // 把proc2赋值给proc1 void Sort( Process pr[], int size) ; // 此排序后按优先级从大到小排列void sort1(Process pr[], int size) ; // 此排序后按需要的cpu时间从小到大排列void Fcfs( Process pr[], int num, int Timepice); // 先来先服务算法void TimeTurn( Process process[], int num, int Timepice); // 时间片轮转算法void Priority( Process process[], int num, int Timepice); // 优先级算法void main(){int a;cout<<endl;cout<<" 选择调度算法："<<endl;cout<<" 1: FCFS 2: 时间片轮换 3: 优先级调度 4: 最短作业优先 5: 最短剩余时间优先"<<endl;cin>>a;const int Size =30;Process process[Size] ;int num;int TimePice;cout<<" 输入进程个数:"<<endl;cin>>num;cout<<" 输入此进程时间片大小: "<<endl;cin>>TimePice;for( int i=0; i< num; i++){string name;int CpuTime;int Leval;cout<<" 输入第"<< i+1<<" 个进程的名字、cpu时间和优先级:"<<endl;cin>>name;cin>> CpuTime>>Leval;process[i].ProcessName =name;process[i].Time =CpuTime;process[i].leval =Leval;cout<<endl;}for ( int k=0;k<num;k++)process[k].LeftTime=process[k].Time ;//对进程剩余时间初始化cout<<" ( 说明: 在本程序所列进程信息中，优先级一项是指进程运行后的优先级!! )";cout<<endl; cout<<endl;cout<<"进程名字"<<"共需占用CPU时间 "<<" 还需要占用时间 "<<" 优先级"<<" 状态"<<endl;if(a==1)Fcfs(process,num,TimePice);else if(a==2)TimeTurn( process, num, TimePice);else if(a==3){Sort( process, num);Priority( process , num, TimePice);}else// 最短作业算法，先按时间从小到大排序，再调用Fcfs算法即可{sort1(process,num);Fcfs(process,num,TimePice);}}void Copy ( Process proc1, Process proc2){proc1.leval =proc2.leval ;proc1.ProcessName =proc2.ProcessName ;proc1.Time =proc2.Time ;}void Sort( Process pr[], int size) //以进程优先级高低排序{// 直接插入排序for( int i=1;i<size;i++){Process temp;temp = pr[i];int j=i;while(j>0 && temp.leval<pr[j-1].leval){pr[j] = pr[j-1];j--;}pr[j] = temp;} // 直接插入排序后进程按优先级从小到大排列for( int d=size-1;d>size/2;d--){Process temp;temp=pr [d];pr [d] = pr [size-d-1];pr [size-d-1]=temp;} // 此排序后按优先级从大到小排列}/* 最短作业优先算法的实现*/void sort1 ( Process pr[], int size) // 以进程时间从低到高排序{// 直接插入排序for( int i=1;i<size;i++){Process temp;temp = pr[i];int j=i;while(j>0 && temp.Time < pr[j-1].Time ){pr[j] = pr[j-1];j--;}pr[j] = temp;}}/* 先来先服务算法的实现*/void Fcfs( Process process[], int num, int Timepice){ // process[] 是输入的进程，num是进程的数目，Timepice是时间片大小while(true){if(num==0){cout<<" 所有进程都已经执行完毕!"<<endl;exit(1);}if(process[0].LeftTime==0){cout<<" 进程"<<process[0].ProcessName<< " 已经执行完毕!"<<endl;for (int i=0;i<num;i++)process[i]=process[i+1];num--;}else if(process[num-1].LeftTime==0){cout<<" 进程"<<process[num-1].ProcessName<< " 已经执行完毕!"<<endl;num--;}else{cout<<endl; //输出正在运行的进程process[0].LeftTime=process[0].LeftTime- Timepice; process[0].leval =process[0].leval-1;cout<<" "<<process[0].ProcessName <<""<<process[0].Time <<" ";cout<<process[0].LeftTime <<""<<process[0].leval<<" 运行";cout<<endl;for(int s=1;s<num;s++){cout<<" "<<process[s].ProcessName <<""<<process[s].Time <<" ";cout<<process[s].LeftTime <<""<<process[s].leval<<" 等待"<<endl; ;}} // elsecout<<endl;system(" pause");cout<<endl;} // while}/* 时间片轮转调度算法实现*/void TimeTurn( Process process[], int num, int Timepice){while(true){if(num==0){cout<<" 所有进程都已经执行完毕!"<<endl;exit(1);}if(process[0].LeftTime==0){cout<<" 进程"<<process[0].ProcessName<< " 已经执行完毕!"<<endl;for (int i=0;i<num;i++)process[i]=process[i+1];num--;}if( process[num-1].LeftTime ==0 ){cout<<" 进程" << process[num-1].ProcessName <<" 已经执行完毕! "<<endl;num--;}else if(process[0].LeftTime > 0){cout<<endl; //输出正在运行的进程process[0].LeftTime=process[0].LeftTime- Timepice;process[0].leval =process[0].leval-1;cout<<" "<<process[0].ProcessName <<""<<process[0].Time <<" ";cout<<process[0].LeftTime <<""<<process[0].leval<<" 运行";cout<<endl;for(int s=1;s<num;s++){cout<<" "<<process[s].ProcessName <<""<<process[s].Time <<" ";cout<<process[s].LeftTime <<""<<process[s].leval;if(s==1)cout<<" 就绪"<<endl;elsecout<<" 等待"<<endl;}Process temp;temp = process[0];for( int j=0;j<num;j++)process[j] = process[j+1];process[num-1] = temp;} // elsecout<<endl;system(" pause");cout<<endl;} // while}/* 优先级调度算法的实现*/void Priority( Process process[], int num, int Timepice){while( true){if(num==0){cout<< "所有进程都已经执行完毕!"<<endl;exit(1);}if(process[0].LeftTime==0){cout<<" 进程" << process[0].ProcessName <<" 已经执行完毕! "<<endl; for( int m=0;m<num;m++)process[m] = process[m+1]; //一个进程执行完毕后从数组中删除num--; // 此时进程数目减少一个}if( num!=1 && process[num-1].LeftTime ==0 ){cout<<" 进程" << process[num-1].ProcessName <<" 已经执行完毕!"<<endl;num--;}if(process[0].LeftTime > 0){cout<<endl; //输出正在运行的进程process[0].LeftTime=process[0].LeftTime- Timepice;process[0].leval =process[0].leval-1;cout<<" "<<process[0].ProcessName <<" "<<process[0].Time <<" ";cout<<process[0].LeftTime <<""<<process[0].leval<<" 运行";cout<<endl; // 输出其他进程for(int s=1;s<num;s++){cout<<" "<<process[s].ProcessName <<" "<<process[s].Time <<" ";cout<<process[s].LeftTime <<""<<process[s].leval ;if(s==1)cout<<" 就绪"<<endl;elsecout<<" 等待 "<<endl;}} // elseSort(process, num);cout<<endl;system(" pause");cout<<endl;} // while}。