下载文档原格式
模拟进程调度实验报告模拟进程调度实验报告引言：进程调度是操作系统中的一个重要功能，它决定了各个进程在处理器上的执行顺序。
合理的进程调度算法能够提高系统的性能和效率。
为了深入了解进程调度算法的工作原理和效果，我们进行了一系列的模拟实验。
实验目的：1. 了解不同进程调度算法的工作原理；2. 分析不同算法对系统性能的影响；3. 探索如何选择合适的进程调度算法。
实验过程：1. 实验环境的搭建我们使用了一台配置较高的计算机作为实验环境，操作系统选择了Linux。
为了模拟多个进程同时运行的情况，我们编写了一段简单的多进程程序，并通过设置不同的优先级和时间片来模拟不同的进程调度算法。
2. FCFS（先来先服务）调度算法FCFS是最简单的进程调度算法，它按照进程到达的顺序进行调度。
我们通过设置不同的进程到达时间，观察FCFS算法的运行情况。
实验结果显示，FCFS算法对于长时间运行的进程效果较好，但是对于短时间进程会出现饥饿现象。
3. SJF（短作业优先）调度算法SJF算法是根据进程的执行时间来进行调度的，执行时间短的进程优先执行。
我们通过设置不同的进程执行时间，观察SJF算法的运行情况。
实验结果显示，SJF算法能够有效地减少平均等待时间和周转时间，但是对于长时间进程会出现饥饿现象。
4. RR（时间片轮转）调度算法RR算法是按照时间片的方式进行调度的，每个进程被分配一个固定的时间片，当时间片用完后，进程被挂起，等待下一次调度。
我们通过设置不同的时间片长度，观察RR算法的运行情况。
实验结果显示，RR算法能够公平地分配CPU 时间，并且能够较好地处理长时间和短时间进程。
实验结果与讨论：通过对不同进程调度算法的模拟实验，我们得出了以下结论：1. FCFS算法适用于长时间运行的进程，但对于短时间进程容易出现饥饿现象。
2. SJF算法能够有效地减少平均等待时间和周转时间，但对于长时间进程也容易出现饥饿现象。
3. RR算法能够公平地分配CPU时间，但对于长时间进程可能会产生较大的上下文切换开销。
实验一、进程调度实验报告一、实验目的进程调度是操作系统中的核心功能之一，其目的是合理地分配 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分析：先来先服务调度算法简单直观，但对于短作业可能会造成较长的等待时间，导致平均等待时间和平均周转时间较长。
竭诚为您提供优质文档/双击可除进程调度算法模拟实验报告篇一：操作系统进程调度算法模拟实验报告进程调度算法模拟专业：xxxxx学号：xxxxx姓名：xxx实验日期：20xx年xx月xx日一、实验目的通过对进程调度算法的模拟加深对进程概念和进程调度算法的理解。
二、实验要求编写程序实现对5个进程的调度模拟，要求至少采用两种不同的调度算法分别进行模拟调度。
三、实验方法内容1.算法设计思路将每个进程抽象成一个控制块pcb，pcb用一个结构体构建一个进程调度类。
将进程调度的各种算法分装在一个类中。
类中存在三个容器，一个保存正在或未进入就绪队列的进程，一个保存就绪的进程，另一个保存已完成的进程。
还有一个pcb实例。
主要保存正在运行的进程。
类中其他方法都是围绕这三个容器可以这个运行中的pcb展开。
主要用到的技术是sTL中的vector以维护和保存进程容器、就绪容器、完成容器。
当程序启动时，用户可以选择不同的调度算法。
然后用户从控制台输入各个进程的信息，这些信息保存到进程容器中。
进程信息输入完毕后，就开始了进程调度，每调度一次判断就绪队列是否为空，若为空则系统时间加一个时间片。
判断进程容器中是否有新的进程可以加入就绪队列。
2.算法流程图主程序的框架：();//先来先服务();//最短进程优先调度//简单时间片轮转//最高优先数优先//输入进程信息();.m_waitQueue.empty()||.m_processQueue.empt() ();进程调度过程：;3.算法中用到的数据结构structfcfs{//先来先服务算法从这里开始charname[10];floatarrivetime;floatservicetime;float starttime;floatfinishtime;floatzztime;floatdqzztime;};//定义一个结构体，里面包含的有一个进程相关的信息4.主要的常量变量vector m_processQueue;//进程输入队列vector m_waitQueue;//进程就绪队列vectorm_FinishQueue;//完成队列vect(:进程调度算法模拟实验报告)or ::iteratorm_iter;//迭代器pcbm_runprocess;//运行中的进程intm_processcount;//进程数floatm_RunTime;//运行时间intm_tagIsRun;//是否在运行标志。
操作系统进程调度算法模拟实验报告一、实验目的本实验旨在深入理解操作系统的进程调度算法，并通过模拟实验来探究不同调度算法之间的差异和优劣。
二、实验原理操作系统的进程调度算法是决定进程执行顺序的重要依据。
常见的调度算法有先来先服务（FCFS）、最短作业优先（SJF）、优先级调度（Priority Scheduling）、轮转法（Round Robin）和多级反馈队列调度（Multilevel Feedback Queue Scheduling）等。
1.先来先服务（FCFS）算法：按照进程到达的先后顺序进行调度，被调度的进程一直执行直到结束或主动阻塞。
2.最短作业优先（SJF）算法：按照进程需要的执行时间的短长程度进行调度，执行时间越短的进程越优先被调度。
3. 优先级调度（Priority Scheduling）算法：为每个进程分配一个优先级，按照优先级从高到低进行调度。
4. 轮转法（Round Robin）算法：将进程按照到达顺序排列成一个队列，每个进程被分配一个时间片（时间量度），当时间片结束时，将进程从队列头取出放置到队列尾。
5.多级反馈队列调度算法：将进程队列分为多个优先级队列，每个队列时间片大小依次递减。
当一个队列中的进程全部执行完毕或者发生阻塞时，将其转移到下一个优先级队列。
三、实验步骤与结果1.实验环境：- 操作系统：Windows 10- 编译器：gcc2.实验过程：（1）首先，设计一组测试数据，包括进程到达时间、需要的执行时间和优先级等参数。
（2）根据不同的调度算法编写相应的调度函数，实现对测试数据的调度操作。
（3）通过模拟实验，观察不同调度算法之间的区别，比较平均等待时间、完成时间和响应时间的差异。
（4）将实验过程和结果进行记录整理，撰写实验报告。
3.实验结果：这里列举了一组测试数据和不同调度算法的结果，以便对比分析：进程，到达时间，执行时间，优先------，----------，----------，-------P1，0，10，P2，1，1，P3，2，2，P4，3，1，P5，4，5，a.先来先服务（FCFS）算法：平均等待时间：3.8完成时间：15b.最短作业优先（SJF）算法：平均等待时间：1.6完成时间：11c. 优先级调度（Priority Scheduling）算法：平均等待时间：2.8完成时间：14d. 轮转法（Round Robin）算法：时间片大小：2平均等待时间：4.8完成时间：17e.多级反馈队列调度算法：第一级队列时间片大小：2第二级队列时间片大小：4平均等待时间：3.8完成时间：17四、实验总结通过上述的实验结果可以得出以下结论：1.在上述测试数据中，最短作业优先（SJF）算法的平均等待时间最短，说明该算法在短作业的情况下能够有效地减少等待时间。
进程调度实验报告一、实验目的。
本实验旨在通过对进程调度算法的模拟和实验，加深学生对进程调度原理的理解，掌握各种进程调度算法的特点和应用场景，提高学生的实际操作能力和分析问题的能力。
二、实验环境。
本次实验使用了C语言编程语言，通过模拟实现了先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转（RR）和多级反馈队列（MFQ）四种进程调度算法。
三、实验过程。
1. 先来先服务（FCFS）调度算法。
先来先服务调度算法是一种非抢占式的调度算法，按照进程到达的先后顺序进行调度。
在本次实验中，我们通过模拟多个进程到达并排队等待CPU执行，观察其平均等待时间和平均周转时间。
实验结果表明，先来先服务调度算法适用于作业长度差异较大的情况，但容易产生“饥饿”现象。
2. 最短作业优先（SJF）调度算法。
最短作业优先调度算法是一种非抢占式的调度算法，按照作业执行时间的长短进行调度。
在本次实验中，我们通过模拟多个作业的执行时间，观察其平均等待时间和平均周转时间。
实验结果表明，最短作业优先调度算法能够最大程度地减少平均等待时间，但可能会导致长作业被“饿死”。
3. 时间片轮转（RR）调度算法。
时间片轮转调度算法是一种抢占式的调度算法，每个进程被分配一个时间片，当时间片用完后，该进程被放到队尾等待。
在本次实验中，我们通过模拟多个进程的执行和时间片的调度，观察其平均等待时间和平均周转时间。
实验结果表明，时间片轮转调度算法能够保证每个进程都能得到一定的执行时间，但可能会导致上下文切换频繁。
4. 多级反馈队列（MFQ）调度算法。
多级反馈队列调度算法是一种综合性的调度算法，根据进程的优先级和执行时间进行动态调整。
在本次实验中，我们通过模拟多个进程的执行和不同优先级队列的调度，观察其平均等待时间和平均周转时间。
实验结果表明，多级反馈队列调度算法能够兼顾短作业和长作业，提高了系统的整体性能。
四、实验总结。
通过本次实验，我们深入理解了不同进程调度算法的特点和适用场景。
【精品】进程调度算法模拟实验报告一、实验目的本实验通过模拟进程的调度算法，使学生掌握多种进程调度算法的实现过程及其优缺点。
二、实验内容本实验实现了三种进程调度算法：先来先服务（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. 实现进程调度模拟程序，包括进程的创建、调度、挂起、恢复和销毁等基本操作。
2. 实现三种常用的调度算法：先来先服务（FCFS）、最短作业优先（SJF）和时间片轮转（RR）。
3. 对比不同调度算法的性能，包括平均等待时间、平均周转时间和平均响应时间等指标。
实验步骤：1. 首先定义进程类Process，包括进程的ID、到达时间、执行时间和优先级等属性。
2. 实现创建进程的函数create_process，通过用户输入的方式创建多个进程，并保存到一个进程队列中。
3. 根据选择的调度算法，实现调度函数schedule，按照对应的算法对进程进行调度，并记录每个进程的执行时间和等待时间等信息。
4. 对于FCFS算法，按照进程的到达时间进行排序，然后按顺序执行。
5. 对于SJF算法，按照进程的执行时间进行排序，然后按顺序执行。
6. 对于RR算法，设定一个时间片大小，每个进程执行一个时间片后，将其放回队列末尾，然后继续执行下一个进程，直到所有进程都执行完毕。
7. 在各个调度算法中计算平均等待时间、平均周转时间和平均响应时间等指标，并输出结果。
实验结果：通过对不同进程和不同调度算法的模拟，可以得到如下结果：1. FCFS调度算法的平均等待时间较长，不适用于执行时间较长的任务。
2. SJF调度算法的平均等待时间和平均周转时间较短，适用于执行时间较短的任务。
3. RR调度算法能够平均分配CPU时间，适用于执行时间较长的任务。
实验总结：通过本次实验，我们进一步加深了对操作系统进程调度的理解和认识。
通过编写模拟程序，我们能够清楚地了解不同调度算法的工作原理和对应的性能表现。
在实际应用中，根据任务的特点和需求选择合适的调度算法，能够提高系统的性能和效率。
第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("无效的调度算法选择。
进程调度模拟实验1.实验目的通过对进程调度算法的模拟加深对进程概念和进程调度过程的理解。
2.实验内容用C语言、Pascal语言或其他开发工具实现对N（N=5）个进程的调度模拟，要求至少采用两种不同的调度算法（如简单轮转法Round Robin和优先权高者优先算法Highest Priority First），分别进行模拟调度。
每个用来标识进程的进程控制块PCB用结构（记录）来描述，根据需要，它包括以下字段：进程标识数ID。
进程优先数Priority，并规定优先数越大的进程，其优先权越高。
采用简单轮转法时该字段无用。
进程已经占用的CPU时间CPUTIME（以时间片为单位，下同）。
进程还需占用的CPU时间ALLTIME。
当进程运行完毕时，ALLTIME变为0。
进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进入阻塞状态。
进程被阻塞的时间BLOCKTIME，表示已经阻塞的进程再等待BLOCKTIME个时间片后，将转换成就绪状态。
进程状态STATE。
队列指针NEXT，用来将PCB排成队列。
优先数改变的原则（采用简单轮转法时该字段无用）：进程在就绪队列中等待一个时间片，优先数增加1；进程每运行一个时间片，优先数减3。
假设在进行调度前，系统中有5个进程，它们的初始状态可以编程输入（更具有灵活性），也可以初始化为如下内容：ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE0 9 0 3 2 3 READY1 38 0 3 -1 0 READY2 30 0 6 -1 0 READY3 29 0 3 -1 0 READY4 0 0 4 -1 0 READY为了清楚地观察诸进程的调度过程，程序应该将每个时间片内各进程的情况显示出来并暂停，参考格式如下：运行/Running：I就绪队列/Ready Queue：Idi，Idj，…阻塞队列/Block Queue：Idk，Idl，…======================================================================进程号优先数已运行时间需要时间开始阻塞时间阻塞时间状态0 P0 C0 A0 T0 B0 S01 P1 C1 A1 T1 B1 S12 P2 C2 A2 T2 B2 S23 P3 C3 A3 T3 B3 S34 P4 C4 A4 T4 B4 S4======================================================================3.实验分析和思考在实际的进程调度中，还有哪些可行的算法，怎样模拟？在实际的进程调度中，除了按算法选择下一个运行的进程之外，操作系统还应该做哪些工作？为什么对进程的优先数可以按上述原则进行修改？有什么好处？4.实验学时安排：6学时，在调度与死锁内容学习之后进行。
// 模拟操作系统四种进程调度算法（先进先出、短进程优先、高优先权优先、简单时间片轮转）// 本实验可以模拟任意一种，可以自定义进程个数、自定义初始化他们的ＰＣＢ。
//Ｃ＋＋代码：#include "stdafx.h"#include <iostream>using std::cout;using std::cin;using std::cerr;enum Status{running,ready,blocked};enum Policy{fifo,spf,hpf,rr};typedef class PCB{//定义ＰＣＢ类。
public:int id,priority,cputime,alltime,startblock,blocktime;Status state;class PCB *next;PCB(){priority=0;}}PCB,*PCBptr,**PCBpp;char x;PCBpp pp;//两个全局变量void Print(PCBptr head){//打印head为头指针的ＰＣＢ链表信息。
PCBptr p;cout<<"\n运行/Running：";for(p=head;p->next;p=p->next){if(p->next->state==running){cout<<"ID"<<p->next->id;break;}}cout<<"\n就绪队列/Ready Queue：";for(p=head;p->next;p=p->next)if(p->next->state==ready)cout<<"ID"<<p->next->id<<' ';cout<<"\n阻塞队列/Block Queue：";for(p=head;p->next;p=p->next)if(p->next->state==blocked)cout<<"ID"<<p->next->id<<' ';cout<<"\n-----------------------------------------------------------------------\n"<<"进程号优先数已运行时间还需要时间开始阻塞时间阻塞时间状态\n";for(p=head;p->next;p=p->next){cout<<""<<p->next->id<<" "<<p->next->priority<<" "<<p->next->cputime<<""<<p->next->alltime<<""<<p->next->startblock<<""<<p->next->blocktime<<""; switch(p->next->state){case ready:cout<<"就绪";break;case running:cout<<"运行";break;case blocked:cout<<"阻塞";break;default:exit(0);}cout<<'\n';}cout<<"------------------------------------------------------------------------\n"<<"按任意键以继续...";cin>>x;}void Delete(PCBptr head,PCBptr p){//删除以head为头指针的ＰＣＢ链表中p所指向的结点。
PCBptr q=head;while(q->next!=p) q=q->next;q->next=p->next;delete p;}void InsertSort(PCBpp Rdy,PCBpp RdyEd,Policy algthm){//直接插入排序。
if(*(Rdy+1))//队列不为空if(RdyEd-1!=Rdy+1){//Ready+1队列中不只一个。
switch(algthm){case hpf:if((*(RdyEd-1))->priority>(*(RdyEd-2))->priority){PCBpp tt;*Rdy=*(RdyEd-1);*(RdyEd-1)=*(RdyEd-2);for(tt=RdyEd-3;(*Rdy)->priority>(*tt)->priority;tt--) *(tt+1)=*tt;*(tt+1)=*Rdy;}break;case spf:if((*(RdyEd-1))->alltime<(*(RdyEd-2))->alltime){PCBpp tt;*Rdy=*(RdyEd-1);*(RdyEd-1)=*(RdyEd-2);for(tt=RdyEd-3;(*Rdy)->alltime<(*tt)->alltime;tt--) *(tt+1)=*tt;*(tt+1)=*Rdy;}}}}void RunToBlk(PCBpp Run,PCBpp &BlkEd){//定义运行态转为阻塞态。
(*Run)->state=blocked;*BlkEd=*Run;BlkEd++;}void RdyToRun(PCBpp &Rdy,PCBpp Run,Policy algthm){//定义就绪态转为运行态。
if(algthm==hpf||algthm==spf){if(*(Rdy+1)){(*(Rdy+1))->state=running;*Run=*(Rdy+1);Rdy++;}}else{if(*Rdy){(*Rdy)->state=running;*Run=*Rdy;Rdy++;}}}void RunToRdy(PCBpp Run,PCBpp Rdy,PCBpp &RdyEd,Policy algthm){//定义运行态转为就绪态。
(*Run)->state=ready;*RdyEd=*Run;RdyEd++;if(algthm==hpf||algthm==spf)InsertSort(Rdy,RdyEd,algthm);}int main(){cout<<"*******************实验开始*******************\n\n需要做几个进程并发执行的实验？"; int n;if(!(cin>>n)) {cerr<<"错误：输入不正确！"; exit(0);}PCBptr Listhead,Listp,Listq;//建立n个Listhead=new PCB; //Listp=Listhead; //for(int i=0;i<=n-1;i++) //{Listq=new PCB; //Listp->next=Listq; //Listp=Listq; //}Listp->next=0; //ＰＣＢ的队列。
