操作系统进程调度算法模拟实验报告
模拟进程调度实验报告
模拟进程调度实验报告模拟进程调度实验报告引言：进程调度是操作系统中的一个重要功能，它决定了各个进程在处理器上的执行顺序。
合理的进程调度算法能够提高系统的性能和效率。
为了深入了解进程调度算法的工作原理和效果，我们进行了一系列的模拟实验。
实验目的：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时间，但对于长时间进程可能会产生较大的上下文切换开销。
进程调度算法模拟实验报告
竭诚为您提供优质文档/双击可除进程调度算法模拟实验报告篇一：操作系统进程调度算法模拟实验报告进程调度算法模拟专业：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;//是否在运行标志。
进程调度算法实验报告
进程调度算法实验报告进程调度算法实验报告一、引言进程调度算法是操作系统中的重要组成部分，它决定了进程在CPU上的执行顺序。
合理的进程调度算法能够提高系统的性能和效率，使得多个进程能够公平地共享CPU资源。
本实验旨在通过实际操作和数据分析，探究不同的进程调度算法对系统性能的影响。
二、实验方法1. 实验环境本次实验使用了一台配置较高的计算机作为实验环境，操作系统为Windows 10。
实验中使用了C语言编写的模拟进程调度程序。
2. 实验步骤（1）编写模拟进程调度程序，实现常见的进程调度算法，包括先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转（RR）和优先级调度（Priority）。
（2）设计一组测试用例，包括不同执行时间的进程和不同优先级的进程。
（3）运行模拟进程调度程序，记录每个进程的等待时间、周转时间和响应时间。
（4）根据实验结果分析不同进程调度算法的性能差异。
三、实验结果与分析1. 先来先服务（FCFS）调度算法先来先服务调度算法按照进程到达的先后顺序进行调度，即先到达的进程先执行。
实验结果显示，该算法对于执行时间较短的进程表现良好，但对于执行时间较长的进程则存在明显的不公平性。
长作业的等待时间较长，导致整体执行效率较低。
2. 最短作业优先（SJF）调度算法最短作业优先调度算法按照进程执行时间的长度进行调度，即执行时间最短的进程先执行。
实验结果显示，该算法能够最大程度地减少平均等待时间和周转时间，提高系统的执行效率。
然而，该算法对于执行时间较长的进程存在饥饿问题，即长作业可能一直等待短作业的执行，导致长作业的等待时间过长。
3. 时间片轮转（RR）调度算法时间片轮转调度算法将CPU的执行时间划分为固定长度的时间片，每个进程按照轮流执行的方式进行调度。
实验结果显示，该算法能够保证每个进程都能够获得一定的执行时间，提高了系统的公平性。
然而，对于执行时间较长的进程而言，由于需要等待其他进程的轮转，其执行效率相对较低。
操作系统-实验五-进程调度与算法模拟-实验报告
计算机与信息工程学院实验报告一、实验内容设计一个按优先数调度算法实现处理器调度的程序。
(1) 假定系统有五个进程，每一个进程用一个进程控制块PCB来代表，进程控制块的格式为：其中，进程名——作为进程的标识，假设五个进程的进程名分别为P1，P2，P3，P4，P5。
指针——按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程中的指针为“0”。
要求运行时间——假设进程需要运行的单位时间数。
优先数——赋予进程的优先数，调度时总是选取优先数大的进程先执行。
状态——可假设有两种状态，“就绪8080”状态和“结束”状态。
五个进程的初始状态都为“就绪”，用“R”表示，当一个进程运行结束后，它的状态为“结束”，用“E”表示。
(2) 在每次运行你所设计的处理器调度程序之前，为每个进程任意确定它的“优先数”和“要求运行时间”。
本实验由于为了检查的方便，优先数和运行时间采用下表中的数值。
(3) 为了调度方便，把五个进程按给定的优先数从大到小连成队列。
用一单元指出队首进程，用指针指出队列的连接情况。
例：队首标志K1K2K3K4K5(4) 处理器调度总是选队首进程运行。
采用动态改变优先数的办法，进程每运行一次优先数就减“1”。
由于本实验是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行：优先数-1要求运行时间-1来模拟进程的一次运行。
提醒注意的是：在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行结束。
在这里省去了这些工作。
(5) 进程运行一次后，若要求运行时间 0，则再将它加入队列（按优先数大小插入，且置队首标志）；若要求运行时间=0，则把它的状态修改成“结束”（E），且退出队列。
(6) 若“就绪”状态的进程队列不为空，则重复上面（4）和（5）的步骤，直到所有进程都成为“结束”状态。
(7) 在所设计的程序中应有显示或打印语句，能显示或打印每次被选中进程的进程名以及运行一次后进程队列的变化。
操作系统进程调度算法模拟实验报告
操作系统进程调度算法模拟实验报告一、实验目的本实验旨在深入理解操作系统的进程调度算法，并通过模拟实验来探究不同调度算法之间的差异和优劣。
二、实验原理操作系统的进程调度算法是决定进程执行顺序的重要依据。
常见的调度算法有先来先服务（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）算法的平均等待时间最短，说明该算法在短作业的情况下能够有效地减少等待时间。
进程调度算法实验报告doc
进程调度算法实验报告篇一：操作系统进程调度算法模拟实验报告进程调度算法模拟专业：XXXXX 学号：XXXXX 姓名：XXX实验日期：20XX年XX月XX日一、实验目的通过对进程调度算法的模拟加深对进程概念和进程调度算法的理解。
二、实验要求编写程序实现对5个进程的调度模拟，要求至少采用两种不同的调度算法分别进行模拟调度。
三、实验方法内容1. 算法设计思路将每个进程抽象成一个控制块PCB， PCB用一个结构体描述。
构建一个进程调度类。
将进程调度的各种算法分装在一个类中。
类中存在三个容器，一个保存正在或未进入就绪队列的进程，一个保存就绪的进程，另一个保存已完成的进程。
还有一个PCB实例。
主要保存正在运行的进程。
类中其他方法都是围绕这三个容器可以这个运行中的PCB展开。
主要用到的技术是STL中的vector以维护和保存进程容器、就绪容器、完成容器。
当程序启动时，用户可以选择不同的调度算法。
然后用户从控制台输入各个进程的信息，这些信息保存到进程容器中。
进程信息输入完毕后，就开始了进程调度，每调度一次判断就绪队列是否为空，若为空则系统时间加一个时间片。
判断进程容器中是否有新的进程可以加入就绪队列。
2. 算法流程图主程序的框架：();//先来先服务();//最短进程优先调度//简单时间片轮转//最高优先数优先//输入进程信息();.m_WaitQueue.empty()||.m_ProcessQueue.empt() ();();进程调度过程：;3. 算法中用到的数据结构struct fcfs{//先来先服务算法从这里开始char name[10];float arrivetime;float servicetime;float starttime;float finishtime;float zztime;floatdqzztime;};//定义一个结构体，里面包含的有一个进程相关的信息4. 主要的常量变量vectorm_ProcessQueue;//进程输入队列vectorm_WaitQueue;//进程就绪队列vectorm_FinishQueue;//完成队列vector::iterator m_iter;//迭代器 PCB m_runProcess;//运行中的进程int m_ProcessCount;//进程数 float m_RunTime;//运行时间int m_tagIsRun;//是否在运行标志。
进程调度操作系统实验报告
进程调度操作系统实验报告一、实验目的本次实验的主要目的是深入理解操作系统中进程调度的概念和原理，通过实际编程和模拟，观察不同调度算法对系统性能的影响，并掌握进程调度的实现方法。
二、实验环境操作系统：Windows 10编程语言：C+＋开发工具：Visual Studio 2019三、实验原理进程调度是操作系统的核心功能之一，它负责决定哪个进程在何时获得 CPU 资源进行执行。
常见的进程调度算法有先来先服务（FCFS）、短作业优先（SJF）、时间片轮转（RR）、优先级调度等。
先来先服务算法按照进程到达的先后顺序进行调度，先到达的进程先获得 CPU 执行。
这种算法简单直观，但可能导致短作业等待时间过长。
短作业优先算法优先调度执行时间短的进程，能有效减少平均等待时间，但可能导致长作业饥饿。
时间片轮转算法将 CPU 时间划分成固定大小的时间片，每个进程轮流获得一个时间片进行执行。
如果进程在时间片内未完成，则被放回就绪队列等待下一轮调度。
优先级调度根据进程的优先级来决定调度顺序，优先级高的进程先获得 CPU 资源。
四、实验步骤1、设计进程结构体定义进程的标识号（PID）、到达时间、服务时间、剩余时间、优先级等属性。
2、实现先来先服务算法按照进程到达的先后顺序将它们放入就绪队列。
从就绪队列中取出第一个进程进行调度执行，直到其完成。
3、实现短作业优先算法计算每个进程的剩余服务时间。
将进程按照剩余服务时间从小到大排序，放入就绪队列。
从就绪队列中取出剩余服务时间最短的进程进行调度执行。
4、实现时间片轮转算法设定时间片大小。
将进程放入就绪队列，按照先来先服务的原则依次分配时间片执行。
进程在时间片内未完成的，放回就绪队列末尾。
5、实现优先级调度算法为每个进程设置优先级。
将进程按照优先级从高到低排序，放入就绪队列。
从就绪队列中取出优先级最高的进程进行调度执行。
6、计算平均周转时间和平均带权周转时间周转时间＝完成时间到达时间带权周转时间＝周转时间／服务时间平均周转时间＝总周转时间／进程数平均带权周转时间＝总带权周转时间／进程数7、输出调度结果包括每个进程的调度顺序、开始时间、结束时间、周转时间、带权周转时间等。
操作系统实验报告——调度算法
操作系统实验报告——调度算法1. 实验目的本实验旨在探究操作系统中常用的调度算法，通过编写代码模拟不同的调度算法，了解它们的特点和应用场景。
2. 实验环境本次实验使用的操作系统环境为Linux，并采用C语言进行编码。
3. 实验内容3.1 调度算法1：先来先服务（FCFS）FCFS调度算法是一种简单且常见的调度算法。
该算法按照进程到达的先后顺序进行调度。
在本实验中，我们使用C语言编写代码模拟FCFS算法的调度过程，并记录每个进程的等待时间、周转时间和响应时间。
3.2 调度算法2：最短作业优先（SJF）SJF调度算法是一种非抢占式的调度算法，根据进程的执行时间来选择下一个要执行的进程。
在本实验中，我们使用C语言编写代码模拟SJF算法的调度过程，并计算每个进程的等待时间、周转时间和响应时间。
3.3 调度算法3：轮转调度（Round Robin）Round Robin调度算法是一种经典的时间片轮转算法，每个进程在给定的时间片内依次执行一定数量的时间。
如果进程的执行时间超过时间片，进程将被暂时挂起，等待下一次轮转。
在本实验中，我们使用C语言编写代码模拟Round Robin算法的调度过程，并计算每个进程的等待时间、周转时间和响应时间。
4. 实验结果分析通过对不同调度算法的模拟实验结果进行分析，可以得出以下结论：- FCFS算法适用于任务到达的先后顺序不重要的场景，但对于执行时间较长的进程可能会导致下一个进程需要等待较久。
- SJF算法适用于任务的执行时间差异较大的场景，能够提高整体执行效率。
- Round Robin算法适用于时间片相对较小的情况，能够公平地为每个进程提供执行时间。
5. 实验总结本次实验通过模拟不同调度算法的实际执行过程，深入了解了各种调度算法的原理、特点和适用场景。
通过对实验结果的分析，我们可以更好地选择合适的调度算法来满足实际应用的需求。
在后续的学习中，我们将进一步探索更多操作系统相关的实验和算法。
实验进程调度的实验报告
一、实验目的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 学生上交实验报告时，必须为打印稿（A4纸）。
页面空间不够，可以顺延。
2 学生应该填写的内容包括：封面相关栏目、实验地点、时间、目的、设备环境、内容、结果及分析等。
3 教师应该填写的内容包括：实验成绩、教师评价等。
《操作系统》课程实验报告int time;//需要在cpu上处理的时间struct node* next;//链指针}PCB;3.实验代码（要求加注释）void insert1(PCB *p,PCB *queue){PCB *q;q=queue;while(q->next)q=q->next;q->next=p;p->next=NULL;}//先来先服务把进程p插入就绪或等待队列的尾部void creat1(int n){PCB *p;int i;ready=new PCB;ready->next=NULL;wait=new PCB;wait->next=NULL;//带头结点的队列run=NULL;for(i=1;i<=n;i++){p=new PCB;cout<<endl<<"请输入进程名称：";cin>>p->name;cout<<"进程状态：";p->state=rand()%2;cout<<p->state;cout<<endl;if(p->state==0)insert1(p,ready);//当state为0时，插入到就绪队列中elseinsert1(p,wait);//否则插入到等待队列中}}void runing(){PCB *p;cout << "当前执行进程：";if(!run)cout<<"空"<<endl<<"就绪队列：";elsecout<<run->name<<endl<<"就绪队列：";if(!ready->next)cout<<"空";elsefor(p=ready->next;p;p=p->next)cout<<p->name<<" ";cout<<endl<<"等待队列：";if(!wait->next)cout<<"空";elsefor(p=wait->next;p;p=p->next)cout<<p->name<<" ";cout<<endl;}void FCFS(int n){srand((int)time(0));int state_change;PCB *p;cout<<endl<<"*********先来先服务*************************"<<endl;creat1(n);srand((int)time(0));cout<<endl<<"运行前："<<endl;runing();cout<<endl;cout<<"运行中："<<endl;while(ready->next||wait->next){if(ready->next){run=ready->next;ready->next=run->next;}runing();state_change=rand()%2;cout<<endl<<"state_change="<<state_change<<endl;if(state_change==1&&wait->next){p=wait->next;wait->next=p->next;insert1(p,ready);}run=NULL;}cout<<endl;}//********************************************************************** void insert2(PCB *p,PCB *queue){PCB *q,*preq;preq=queue;q=queue->next;while(q&&(q->prio)<=(p->prio)){preq=q;q=q->next;}if(!q){preq->next=p;p->next=NULL;}else{p->next=q;preq->next=p;}}//把p插入优先级队列中，队列仍然按照优先级高低排列void creat2(int n){srand((int)time(0));PCB *p;run=NULL;for(int i=0;i<n;i++){p=new PCB;cout<<endl<<"请输入进程名称：";cin>>p->name;cout<<"进程状态：";p->state=rand()%2;cout<<p->state;cout<<endl<<"进程的优先级：";p->prio=rand()%5+1;cout<<p->prio;cout<<endl<<"进程需要的执行时间：";p->time=rand()%10+1;cout<<p->time;cout<<endl;if(p->state==0)insert2(p,ready);//当state为0时，插入到就绪队列中elseinsert1(p,wait);//否则插入到等待队列中}}void FPF(int n){srand((int)time(0));int wait_state_change,run_state_change,cpu_time=rand()%5+1;//cpu_time表示一次在cpu上的执行时间PCB *p;cout<<"************高优先级********************************"<<endl<<"cpu_time="<<cpu_time;creat2(n);srand((int)time(0));cout<<endl<<"运行前："<<endl;runing();cout<<endl;cout<<"运行中："<<endl;while(ready->next||wait->next){if(ready->next){run=ready->next;ready->next=run->next;}runing();wait_state_change=rand()%2;cout<<"wait_state_change="<<wait_state_change<<endl;if(wait_state_change==1&&wait->next){p=wait->next;wait->next=p->next;insert1(p,ready);}if(run&&run->time>cpu_time){run->time-=cpu_time;run_state_change=rand()%2;cout<<"run_state_change="<<run_state_change<<endl;if(run&&run_state_change==0&&run->time>0)insert1(run,ready);elseinsert1(run,wait);}else run=NULL;}cout<<endl;}//********************************************************************** void insert3(PCB *p,PCB *queue){PCB *q,*preq;preq=queue;q=queue->next;while(q&&(q->time)<=(p->time)){preq=q;q=q->next;}if(!q){preq->next=p;p->next=NULL;}else{p->next=q;preq->next=p;}}//把p插入作业按时间排列的队列中，队列仍然按照时间长短排列void creat3(int n){srand((int)time(0));PCB *p;run=NULL;for(int i=0;i<n;i++){p=new PCB;cout<<"请输入进程名称：";cin>>p->name;cout<<"进程状态：";p->state=rand()%2;cout<<p->state;cout<<endl<<"进程需要的执行时间：";p->time=rand()%10+1;cout<<p->time;cout<<endl<<endl;if(p->state==0)insert3(p,ready);//当state为0时，插入到就绪队列中elseinsert1(p,wait);//否则插入到等待队列中}}void SPF(int n){srand((int)time(0));int state_change;PCB *p;cout<<"***********短作业优先*******************************"<<endl;creat3(n);cout<<endl<<"运行前："<<endl;runing();srand((int)time(0));cout<<endl<<"运行中："<<endl;while(ready->next||wait->next){if(ready->next){run=ready->next;ready->next=run->next;}runing();state_change=rand()%2;cout<<endl<<"state_change="<<state_change<<endl;if(state_change==1&&wait->next){p=wait->next;wait->next=p->next;insert1(p,ready);}run=NULL;}。
操作系统进程调度模拟程序实验报告
操作系统进程调度模拟程序实验报告实验目的：了解操作系统进程调度的基本原理和方法，通过编写模拟程序来验证调度算法的正确性。
实验内容：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时间，适用于执行时间较长的任务。
实验总结：通过本次实验，我们进一步加深了对操作系统进程调度的理解和认识。
通过编写模拟程序，我们能够清楚地了解不同调度算法的工作原理和对应的性能表现。
在实际应用中，根据任务的特点和需求选择合适的调度算法，能够提高系统的性能和效率。
进程的调度实验报告(3篇)
第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、课程设计目的 (3)2、课程设计要求 (3)3、相关知识 (3)4、需求分析 (4)5、概要设计 (5)6、详细设计 (6)7、测试，修改及运行结果 (13)8、参考文献 (15)9、结束语 (15)10、附件 (15)1、课程设计的目的理解操作系统进程管理中进行进程调度的过程和编程方法，掌握先来先服务调度算法和最高优先数优先的调度算法，创建进程控制块PCB。
理解进程的状态及变化，动态显示每个进程的当前状态及进程的调度情况2、课程设计要求编写一个进程调度程序，允许多个进程共行的进程调度程序1）.进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。
2）.每个进程有一个进程控制块（ PCB）表示。
进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等.3）.进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。
进程的到达时间为输入进程的时间。
4）．进程的运行时间以时间片为单位进行计算。
5）.每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
.6）.就绪进程获得 CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
7）.如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
8）.每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止3、相关知识进程：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动进程的状态：运行状态：进程正在处理器上运行就绪状态：一个进程获得了除处理器外的一切所需资源，一旦得到处理器即可运行等待状态：一个进程正在等待某一事件发生而暂时停止运行先进先出调度算法：其基本原则是按照作业到达系统或进程进入就绪对列的先后次序来选择。
模拟调度实验报告(3篇)
第1篇一、实验背景进程调度是操作系统核心功能之一，它负责在多道程序环境下，按照一定的策略对进程进行调度，以确保系统资源的合理分配和高效利用。
为了加深对进程调度算法的理解，本次实验采用模拟的方式，实现了先来先服务（FCFS）、时间片轮转（RR）和动态优先级调度（DP）三种算法，并对实验过程进行了详细记录和分析。
二、实验目的1. 理解进程调度的基本原理和不同调度算法的特点。
2. 掌握进程控制块（PCB）的设计与实现。
3. 通过模拟实验，验证三种调度算法的执行效果。
三、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发环境：Visual Studio 2019四、实验内容1. 定义进程控制块（PCB）进程控制块是操作系统用于描述和管理进程的实体，它包含了进程的基本信息。
本实验中，PCB包含以下字段：- 进程ID：唯一标识一个进程。
- 到达时间：进程进入就绪队列的时间。
- 需要运行时间：进程完成所需的时间。
- 已运行时间：进程已运行的时间。
- 状态：进程当前的状态（就绪、运行、阻塞、完成）。
2. 实现三种调度算法（1）先来先服务（FCFS）算法FCFS算法按照进程到达就绪队列的顺序进行调度，先到先服务。
具体实现如下：- 将进程按照到达时间排序，形成就绪队列。
- 遍历就绪队列，依次执行进程，直到进程完成或被阻塞。
（2）时间片轮转（RR）算法RR算法将CPU时间划分为时间片，每个进程运行一个时间片后，让出CPU，等待下一个时间片。
具体实现如下：- 设置一个时间片大小。
- 将进程按照到达时间排序，形成就绪队列。
- 遍历就绪队列，每个进程执行一个时间片，如果进程未完成，则将其加入就绪队列队尾。
（3）动态优先级调度（DP）算法DP算法根据进程的优先级进行调度，优先级高的进程优先执行。
具体实现如下：- 设置一个优先级阈值，当进程的优先级高于阈值时，将其加入就绪队列。
- 遍历就绪队列，选择优先级最高的进程执行，直到进程完成或被阻塞。
操作系统进程调度实验报告
操作系统进程调度实验报告操作系统进程调度实验报告引言：操作系统是计算机系统中的核心软件之一，负责管理计算机的硬件资源并提供用户与计算机硬件之间的接口。
进程调度作为操作系统的重要功能之一，负责决定哪个进程可以获得处理器的使用权，以及进程如何在处理器上运行。
本实验旨在通过设计和实现一个简单的进程调度算法，加深对操作系统进程调度原理的理解。
一、实验目的本实验的主要目的是通过编写代码模拟操作系统的进程调度过程，掌握进程调度算法的实现方法，深入理解不同调度算法的特点和适用场景。
二、实验环境本实验使用C语言进行编程实现，可在Linux或Windows系统下进行。
三、实验内容1. 进程调度算法的选择在本实验中，我们选择了最简单的先来先服务（FCFS）调度算法作为实现对象。
FCFS算法按照进程到达的先后顺序进行调度，即先到先服务。
这种调度算法的优点是简单易实现，但缺点是无法适应不同进程的执行时间差异，可能导致长作业效应。
2. 进程调度的数据结构在实现进程调度算法时，我们需要定义进程的数据结构。
一个进程通常包含进程ID、到达时间、执行时间等信息。
我们可以使用结构体来表示一个进程，例如：```struct Process {int pid; // 进程IDint arrival_time; // 到达时间int burst_time; // 执行时间};```3. 进程调度算法的实现在FCFS调度算法中，我们需要按照进程到达的先后顺序进行调度。
具体实现时，可以使用一个队列来保存待调度的进程，并按照到达时间的先后顺序将进程入队。
然后，按照队列中的顺序依次执行进程，直到所有进程执行完毕。
4. 实验结果分析通过实现FCFS调度算法，我们可以观察到进程调度的过程和结果。
可以通过输出每个进程的执行顺序、等待时间和周转时间等指标来分析调度算法的效果。
通过比较不同调度算法的指标，可以得出不同算法的优缺点。
四、实验步骤1. 定义进程的数据结构，包括进程ID、到达时间和执行时间等信息。
进程调度算法模拟实验报告
竭诚为您提供优质文档/双击可除进程调度算法模拟实验报告篇一：操作系统进程调度算法模拟实验报告进程调度算法模拟专业：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;//是否在运行标志。
调度算法实验报告总结(3篇)
第1篇一、实验目的本次实验旨在通过模拟操作系统中的进程调度过程，加深对进程调度算法的理解。
实验中，我们重点研究了先来先服务（FCFS）、时间片轮转（RR）和动态优先级调度（DP）三种常见的调度算法。
通过编写C语言程序模拟这些算法的运行，我们能够直观地观察到不同调度策略对进程调度效果的影响。
二、实验内容1. 数据结构设计在实验中，我们定义了进程控制块（PCB）作为进程的抽象表示。
PCB包含以下信息：- 进程编号- 到达时间- 运行时间- 优先级- 状态（就绪、运行、阻塞、完成）为了方便调度，我们使用链表来存储就绪队列，以便于按照不同的调度策略进行操作。
2. 算法实现与模拟（1）先来先服务（FCFS）调度算法FCFS算法按照进程到达就绪队列的顺序进行调度。
在模拟过程中，我们首先将所有进程按照到达时间排序，然后依次将它们从就绪队列中取出并分配CPU资源。
（2）时间片轮转（RR）调度算法RR算法将CPU时间划分为固定的时间片，并按照进程到达就绪队列的顺序轮流分配CPU资源。
当一个进程的时间片用完时，它将被放入就绪队列的末尾，等待下一次调度。
（3）动态优先级调度（DP）算法DP算法根据进程的优先级进行调度。
在模拟过程中，我们为每个进程分配一个优先级，并按照优先级从高到低的顺序进行调度。
3. 输出调度结果在模拟结束后，我们输出每个进程的调度结果，包括：- 进程编号- 到达时间- 运行时间- 等待时间- 周转时间同时，我们还计算了平均周转时间、平均等待时间和平均带权周转时间等性能指标。
三、实验结果与分析1. FCFS调度算法FCFS算法简单易实现，但可能会导致进程的响应时间较长，尤其是在存在大量短作业的情况下。
此外，FCFS算法可能导致某些进程长时间得不到调度，造成饥饿现象。
2. 时间片轮转（RR）调度算法RR算法能够有效地降低进程的响应时间，并提高系统的吞吐量。
然而，RR算法在进程数量较多时，可能会导致调度开销较大。
进程调度算法 实验报告
进程调度算法实验报告进程调度算法实验报告一、引言进程调度算法是操作系统中非常重要的一部分，它决定了系统中各个进程的执行顺序和时间分配。
在本次实验中，我们将研究和比较几种常见的进程调度算法，包括先来先服务（FCFS）、最短作业优先（SJF）、轮转法（RR）和优先级调度算法。
二、实验目的本次实验的目的是通过模拟不同的进程调度算法，观察它们在不同情况下的表现，并比较它们的优缺点，以便更好地理解和应用这些算法。
三、实验过程1. 实验环境准备我们使用C语言编写了一个简单的进程调度模拟程序，该程序可以模拟不同的进程调度算法，并输出每个进程的执行顺序和等待时间等信息。
2. 实验步骤（1）先来先服务（FCFS）算法FCFS算法是最简单的一种进程调度算法，它按照进程的到达顺序来执行。
我们通过模拟多个进程的到达时间和执行时间，观察它们的执行顺序和等待时间。
（2）最短作业优先（SJF）算法SJF算法是根据进程的执行时间来进行调度的，执行时间越短的进程优先执行。
我们通过模拟多个进程的执行时间，观察它们的执行顺序和等待时间。
（3）轮转法（RR）算法RR算法是一种时间片轮转的调度算法，每个进程被分配一个时间片，当时间片用完后，进程被挂起，等待下一次调度。
我们通过模拟不同的时间片大小，观察进程的执行顺序和等待时间。
（4）优先级调度算法优先级调度算法是根据进程的优先级来进行调度的，优先级高的进程优先执行。
我们通过模拟不同的进程优先级，观察进程的执行顺序和等待时间。
四、实验结果与分析1. 先来先服务（FCFS）算法当进程的执行时间相差不大时，FCFS算法的等待时间较长，因为后到达的进程需要等待前面的进程执行完毕。
但如果有一个进程的执行时间很长，其他进程的等待时间就会很短。
2. 最短作业优先（SJF）算法SJF算法能够保证最短执行时间的进程先执行，因此平均等待时间较短。
但如果有一个执行时间很长的进程到达，其他进程的等待时间就会变长。
操作系统进程调度模拟程序实验报告
操作系统进程调度模拟程序实验报告一、实验目的本次实验旨在通过编写一个模拟操作系统进程调度的程序，以加深对进程调度算法的理解。
二、实验内容1. 实现进程相关的数据结构：进程PCB（Process Control Block）。
2.实现进程的创建、撤销以及调度等操作函数。
3. 实现常见的进程调度算法：先来先服务（FCFS）、最短作业优先（SJF）、轮转调度（RR）、优先级调度（Priority）。
4.编写测试程序，验证实现的进程调度算法在不同场景下的表现。
三、实验过程及结果1.进程PCB的设计与实现进程PCB是进程的核心数据结构，用于存储和管理进程相关的信息，包括进程状态（就绪、运行、阻塞）、优先级、执行时间等。
2.进程的创建、撤销及调度函数的实现（1）进程创建函数：实现进程的创建，包括为其分配空间、初始化进程PCB等。
可以根据实际需求，设定进程的优先级、执行时间等属性。
（2）进程撤销函数：实现进程的撤销，包括释放其占用的资源、回收其使用的空间等。
（3）进程调度函数：根据不同的调度算法，实现进程的调度。
可以通过设置时间片大小、优先级设定等方式，实现不同调度算法的效果。
3.进程调度算法的设计与实现（1）先来先服务（FCFS）调度算法：按照进程到达的先后顺序，依次进行调度。
（2）最短作业优先（SJF）调度算法：根据进程的执行时间，选择执行时间最短的进程进行调度。
（3）轮转调度（RR）算法：按照时间片的大小进行调度，每个进程在一个时间片内执行，超过时间片后，暂停并进入等待队列，让其他进程执行。
（4）优先级调度（Priority）算法：根据进程的优先级，选择优先级最高的进程进行调度。
4.测试程序编写测试程序，模拟不同的进程到达顺序、执行时间和优先级等场景，验证不同调度算法的表现。
四、实验结果与分析通过测试程序的运行结果，观察不同调度算法的特点和效果。
可以得出以下结论：1.FCFS算法适用于进程到达时间差异较大的场景，保证了先到先服务。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
进程调度算法模拟专业：XXXXX学号：XXXXX姓名：XXX实验日期：20XX 年XX 月XX 日一、实验目的通过对进程调度算法的模拟加深对进程概念和进程调度算法的理解。
二、实验要求编写程序实现对 5 个进程的调度模拟，要求至少采用两种不同的调度算法分别进行模拟调度。
三、实验方法内容1. 算法设计思路将每个进程抽象成一个控制块PCB，PCB 用一个结构体描述。
构建一个进程调度类。
将进程调度的各种算法分装在一个类中。
类中存在三个容器，一个保存正在或未进入就绪队列的进程，一个保存就绪的进程，另一个保存已完成的进程。
还有一个PCB 实例。
主要保存正在运行的进程。
类中其他方法都是围绕这三个容器可以这个运行中的PCB 展开。
主要用到的技术是STL 中的vector 以维护和保存进程容器、就绪容器、完成容器。
当程序启动时，用户可以选择不同的调度算法。
然后用户从控制台输入各个进程的信息，这些信息保存到进程容器中。
进程信息输入完毕后，就开始了进程调度，每调度一次判断就绪队列是否为空，若为空则系统时间加一个时间片。
判断进程容器中是否有新的进程可以加入就绪队列。
2. 算法流程图主程序的框架：进程调度过程：3. 算法中用到的数据结构struct fcfs{ //先来先服务算法从这里开始char name[10];float arrivetime;float servicetime;float starttime;float finishtime;float zztime;float dqzztime;}; //定义一个结构体，里面包含的有一个进程相关的信息4. 主要的常量变量vector < PCB>m_ProcessQueue; // 进程输入队列vector <PCB>m_WaitQueue; // 进程就绪队列vector vector <PCB>m_FinishQueue ; // 完成队列<PCB>:: iterator m_iter ; // 迭代器PCBm _runProcess ; // 运行中的进程int m_ProcessCount; // 进程数 float m_RunTime; // 运行时间 int m_tagIsRun ; // 是否在运行标志。
表示正在运行，表示没有 float m_TimeSlice ;// 时间片大小开始int m_TimeSliceCount ; // 指时间片轮转中一次分到的时间片个数char m_SchedulerAlgorithm ;// 调度算法5. 主要模块void PCBInput (); // 输入进程信息void PCBSort(); // 对进程控制块按照优先级排序( 采用冒泡排序)void ProcessSelect (); // 若当前就绪队列不为空则根据选择的调度算法开始调度。
否则，系统时间加. 以等待新的进程到来void PCBDisplay (); // 打印当前状况下。
就绪队列、完成队列、运行中的进程信息void ProcessRun (); // 进程运行一次。
运行时间加个时间片。
并判断进程是否达到完成条件。
若是则ProcessStatus='f'. 否则为'w';void ProcessQueueProcess (); // 查看当前时间下，有无进程加入。
若有则把该进程调入就绪队列void ProcessDispatch (); // 进程分派，进程执行完成后决定进程该进入哪个队列( 就绪、完成) void TimePast (){ m_RunTime += m_TimeSlice ; ProcessQueueProcess ();} // 当前系统时间加个时间片，并检查是否有新的进程加入void SchedulerStatistics (); // 调度统计，计算周转时间等void FCFS(); // 先来先服务void SJF(); // 最短进程优先调度void RR(); // 简单时间片轮转void PD(); // 最高优先数优先四、实验代码#include <cstdlib>#include <iostream>#include<iomanip>using namespace std;struct fcfs{ //先来先服务算法从这里开始char name[10];float arrivetime;float servicetime;float starttime;float finishtime;float zztime;float dqzztime;}; //定义一个结构体，里面包含的有一个进程相关的信息fcfs a[100];void input(fcfs *p,int N){ int i; cout<<endl; printf(" 请您输入进程的名字到达时间服务时间: (例如: a 0100)\n\n");for(i=0;i<=N-1;i++){printf(" 请您输入进程%d 的信息:\t",i+1);scanf("\t\t\t%s%f%f",&p[i].name,&p[i].arrivetime,&p[i].servicetime);}}void Print(fcfs *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float dqzztime,int N){int k;printf("\n\n 调用先来先服务算法以后进程运行的顺序是: ");printf("%s",p[0].name);for(k=1;k<N;k++){printf("-->%s",p[k].name);}cout<<endl;printf("\n 具体进程调度信息:\n");printf("\t 进程名到达时间服务时间开始时间结束时间周转时间带权周转时间\n");for(k=0;k<=N-1;k++){printf("\t%s\t%-.2f\t %-.2f\t %-.2f\t %-.2f\t %-.2f\t %-.2f\n",p[k].name,p[k].arrivetime,p[k].servicetime,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].dqzztime);}getchar(); //此处必须要有这个函数，否则就看不到显示器上面的输出，可以看到的结果只是一闪而过的一个框剪}void sort(fcfs *p,int N) // 排序for(int i=0;i<=N-1;i++)for(int j=0;j<=i;j++)if(p[i].arrivetime<p[j].arrivetime){fcfs temp;temp=p[i];p[i]=p[j];p[j]=temp;}}void deal(fcfs *p, float arrivetime,float servicetime,float starttime,float finishtime,float &zztime,float &dqzztime,int N) //运行阶段{int k;for(k=0;k<=N-1;k++){if(k==0){p[k].starttime=p[k].arrivetime;p[k].finishtime=p[k].arrivetime+p[k].servicetime;}{else{p[k].starttime=p[k-1].finishtime;p[k].finishtime=p[k-1].finishtime+p[k].servicetime;}}for(k=0;k<=N-1;k++){p[k].zztime=p[k].finishtime-p[k].arrivetime;p[k].dqzztime=p[k].zztime/p[k].servicetime;}}void FCFS(fcfs *p,int N){floatarrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0;sort(p,N);deal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);Print(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);getchar();} // 先来先服务算法到此结束struct sjf{// 最短进程优先调度算法从这里开始char name[10];float arrivetime; //到达时间float servicetime; //运行时间float starttime; // 开始时间float finishtime; //完成时间};sjf a1[100];void input(sjf *p,int N1)// 进程信息输入{int i; cout<<endl; printf(" 请您输入进程的名字到达时间服务时间: (例如: a 0 100)\n");for(i=0;i<=N1-1;i++) {printf(" 请您输入进程%d 的信息:\t",i+1);scanf("\t\t\t%s%f%f",&p[i].name,&p[i].arrivetime,&p[i].servicetime);}}void Print(sjf *p,float arrivetime,float servicetime,float starttime,float finishtime,int N1)// 最终结果输出{int k; printf("\n\t 调用最短进程优先调度算法以后进程的调度顺序为:"); printf("%s",p[0].name);for(k=1;k<N1;k++) {printf("-->%s",p[k].name);} cout<<endl;printf("\n 给个进程具体调度信息如下:\n"); printf("\n\t 进程名\t 到达时间\t 运行时间\t 开始时间\t 完成时间\n");for(k=0;k<=N1-1;k++){printf("\t%s\t %-.2f\t\t %-.2f\t\t %-.2f\t\t %-.2f\t\n",p[k].name,p[k].arrivetime,p[k].servicetime,p[k].starttime,p[k].finishtime);getchar();}void sort(sjf *p,int N1)// 排序{for(int i=0;i<=N1-1;i++)for(int j=0;j<=i;j++)if(p[i].arrivetime<p[j].arrivetime){sjf temp;}temp=p[i];p[i]=p[j];p[j]=temp;}}void deal(sjf *p, float arrivetime,float servicetime,float starttime,float finishtime,int N1)// 运行阶段{ int k;for(k=0;k<=N1-1;k++){if(k==0){p[k].starttime=p[k].arrivetime;p[k].finishtime=p[k].arrivetime+float(p[k].servicetime)/60;}else{p[k].starttime=p[k-1].finishtime;p[k].finishtime=p[k-1].finishtime+float(p[k].servicetime)/60;}}}void sjff(sjf *p,int N1){float arrivetime=0,servicetime=0,starttime=0,finishtime=0;sort(p,N1);for(int m=0;m<N1-1;m++){if(m==0)p[m].finishtime=p[m].arrivetime+float(p[m].servicetime)/60; else p[m].finishtime=p[m-1].finishtime+float(p[m].servicetime)/60;int i=0;for(int n=m+1;n<=N1-1;n++){ if(p[n].arrivetime<=p[m].finishtime) i++;}float min=p[m+1].servicetime;int next=m+1;for(int k=m+1;k<m+i;k++){if(p[k+1].servicetime<min) {min=p[k+1].servicetime; next=k+1;}}sjf temp; temp=p[m+1]; p[m+1]=p[next]; p[next]=temp;}deal(p,arrivetime,servicetime,starttime,finishtime,N1);Print(p,arrivetime,servicetime,starttime,finishtime,N1); getchar();}//最短进程优先调度算法到这里结束char menu()//用来输出相关信息的函数{char cse1;while(1){ system("cls"); fflush(stdin); cout<<endl; cout<<endl;cout<<"\t"<<"|| <<<<<<<<<<<< 欢<<<<<<<<<<< >>>>>>>>>>>> 迎>>>>>>>>>>> ||"<<endl ;cout<<"\t"<<"||||"<<endl ;cout<<"\t"<<"||"<<"\t 进程调度算法模拟"<<"\t\t"<<"||"<<endl;cout<<"\t"<<"||||"<<endl ;cout<<"\t"<<"||"<<"\t\t 1. 先来先服务调度算法"<<"\t\t"<<"||"<<endl;cout<<"\t"<<"||||"<<endl ;cout<<"\t"<<"||"<<"\t\t 2.最短进程优先调度算法"<<"\t\t"<<"||"<<endl;cout<<"\t"<<"||||"<<endl ;cout<<"\t"<<"|| <<<<<<<<<<<<<<<<<<<<<<<<< 您>>>>>>>>>>>>>>>>>>>>>>>>> ||"<<endl ;cout<<endl;cout<<endl;cout<<"\t\t 请输入您的选择( 1/2)："; cse1=getchar();if(cse1<'1'||cse1>'2')cout<<"你的输入有错！"<<endl;elsebreak;}return cse1;}int main(int argc, char *argv[]){while(1){switch(menu()){case '1':int N;cout<<endl;cout<<endl;printf("\t\t<<---!!!@@@ 先来先服务调度算法@@@!!!--->>\n");cout<<endl;printf(" 输入进程数目:");scanf("%d",&N);input(a,N);FCFS(a,N);case '2': int N1; cout<<endl; cout<<endl; printf("\t\t<<---!!!@@@ 最短进程优先调度算法@@@!!!--->>\n");cout<<endl; printf(" 输入进程数目: ");scanf("%d",&N1); input(a1,N1);sjf *b=a1; sjf *c=a1; sjff(b,N1); getchar();}} system("PAUSE"); return EXIT_SUCCESS;}五、实验结果1. 执行结果2. 结果分析先来先服务调度算法就是根据进程达到的时间为依据，哪一个进程先来那么该进程就会先执行；最短进程优先调度算法则是以每个进程执行所需时间长短为依据，某一个进程执行所需花的时间要短些那么该进程就先执行。