操作系统课程设计报告-进程调度算法模拟
(完整word版)操作系统-进程调度算法设计与实现实验报告
实验报告课程名称操作系统实验名称进程调度算法设计与实现姓名学号专业班级实验日期成绩指导教师(①实验目的②实验设备和环境③实验内容与步骤④实验结果与分析⑤总结,问题及建议）一、内容：设计一个简单的进程调度算法，模拟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。
进程调度算法模拟 (操作系统课程设计报告)
福建农林大学计算机与信息学院课程设计报告课程名称：操作系统实习题目：进程调度算法模拟姓名：系：计算机科学与技术系专业：计算机科学与技术年级：2012学号：指导教师：职称：副教授年月日福建农林大学计算机与信息学院计算机类课程设计结果评定目录1.本选题课程设计的目的 (4)2.本选题课程设计的要求 (4)3.本选题课程设计报告内容 (4)3．1前言 (4)3．2进程调度算法模拟的环境 (4)3．3系统技术分析 (4)3．4系统流程图及各模块 (5)3．5程序调试情况 (8)4．总结 (11)参考文献 (11)程序代码 (12)1.设计目的课程设计将课本上的理论知识和实际有机的结合起来，锻炼学生的分析系统，解决实际问题的能力。
提高学生分析系统、实践编程的能力。
2.设计要求利用学到的操作系统和编程知识，完成具有一定难度的系统分析研究或系统设计题目。
其中：专题系统理论研究应包括研究目的、目标，论点和论据以及证明推导等；分析、设计系统应包括编写、调试程序以及最后写出设计报告或系统说明文档文件，系统说明文档包括系统界面、变量说明、系统功能说明、编程算法或思路、流程图和完整程序。
具体要求如下：1、对系统进行功能模块分析、控制模块分析正确；2、系统设计要实用；3、编程简练，可用，功能全面；4、说明书、流程图要清楚。
3.设计方案3.1前言本程序包括三种算法，用C或C++语言实现，执行时在主界面选择算法（可用函数实现），进入子页面后输入进程数，（运行时间，优先数由随机函数产生），执行，显示结果。
3.2本选题设计的环境WindowsXP下的Microsoft Visual C++ 6.03.3系统技术分析（1）编程实现对N个进程采用某种进程调度算法（如动态优先权调度算法、先来先服务算法、短进程优先算法、时间片轮转调度算法）调度执行的模拟。
（2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：进程标识数ID。
操作系统-实验五-进程调度与算法模拟-实验报告
计算机与信息工程学院实验报告一、实验内容设计一个按优先数调度算法实现处理器调度的程序。
(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;//是否在运行标志。
操作系统课程设计报告---进程调度的模拟实现
操作系统课程设计报告专业计算机科学与技术学生姓名班级学号指导教师完成日期题目：进程调度的模拟实现的模拟实现一、设计目的本课程设计是学习完“操作系统原理”课程后进行的一次全面的综合训练，通过课程设计，更好地掌握操作系统的原理及实现方法，加深对操作系统基础理论和重要算法的理解，加强学生的动手能力。
在多道程序和多任务系统中，系统内同时处于就绪状态的进程可能有若干个。
也就是说能运行的进程数大于处理机个数。
为了使系统中的进程能有条不紊地工作，必须选用某种调度策略，选择一进程占用处理机。
要求学生设计一个模拟处理机调度算法，以巩固和加深处理机调度的概念。
二、设计内容1）概述选择一个调度算法，实现处理机调度。
设计要求：1）进程调度算法包括：时间片轮转法，短作业优先算法，动态优先级算法。
2）可选择进程数量3）本程序包括三种算法，用C或C++语言实现，执行时在主界面选择算法（可用函数实现），进入子页面后输入进程数，（运行时间，优先数由随机函数产生），执行，显示结果。
调度时总是选取优先数最大的进程优先运行2．每个进程的优先数，运行时间，由程序任意指定。
3．为了调度方便，把进程按给定优先级（动态优先级算法中）从小到大排成一个队列。
按给定运行时间（短作业优先）从小到大排成一个队列用一个变量作为队首指针，指向队列的第一个进程。
4．处理机调度总是选队首进程运行。
由于本实验是模拟处理机调度，所以被选中的进程并不实际的启动运行，而是执行：优先数-1（动态优先级算法中）要求运行时间-1来模拟进程的一次运行。
5．进程运行一次后，若要求运行时间不等于0，则再将它加入队列（动态优先级算法中：按优先数大小插入。
），且改变队首指针：若要求运行时间=0，则把它的状态改为完成（C）状态，且退出队列。
2. 实验分析(1)PCB结构通常包括以下信息：进程名，进程优先数，轮转时间片，进程已占用的CPU时间，进程还需要的CPU时间，进程的状态，当前队列指针等。
操作系统进程调度模拟课程设计(java)
计算机操作系统课程设计实验报告题目名称进程调度模拟系统院系班级完成时间2013.1.8 指导老师本次实验成绩组长联系电话邮件地址组长（姓名、学号）主要任务需求分析，模块设计与代码编写，组织任务分配，PPT制作，实验报告审定,材料汇总等成员（姓名、学号）主要任务代码的编写实验报告的编写、材料查找等题目进程调度：模拟FCFS和SJF进程调度过程实验介绍原理现在的处理机任务量大，多个进程会不同时先后到达，并且各个进程的工作时间也不一定相同，为了使各个进程间不发生冲突，有条不紊的先后运行，并以最短的时间占用处理机，面对这种发展状况，有必要使用进程调度算法来提高处理机的工作效率。
去选择合适的一种进程调度算法达到理想的效果，可以做到信息的规范管理、科学统计和快速运作，从而减少时间上的浪费。
用Java语句设计实现登陆界面，直观显示各种算法和调度结果，直观地显示运行结果，设计进程调度算法实现用不同算法（先来先服务，短作业优先，高响应比优先调度算法，时间片轮转算法）进行进程调度，算出最短周转时间，实现高效率调度算法。
参考资料[1] 黄祥喜，计算机操作系统实验教程。
广州：中山大学出版社，1994.[2] 汤子瀛，《计算机操作系统(修订版)》西安电子科技大学出版社[3] Andrew S.Tanenbaum，现代操作系统，机械工业出版社。
[4] (美)Bruce Eckel. Java编程思想. 陈昊鹏译. 北京：机械工业出版社，2007[5] 王路群.Java高级程序设计.北京：中国水利水电出版社，2006[6] 孙卫琴. 精通Struts：基于MVC的Java Web设计与开发.北京：电子工业出版社，2004.08实验环境（软件和硬件）：（1）硬件要求EGA或VGA卡彩显或单显(640×350以上),单机内存2M以上,硬盘40M 以上。
客户端计算机采用586以上机型，客户端应用程序可以稳定的运行在Windows07 xp操作系统之上。
操作系统课程设计报告进程调度算法
操作系统课程设计报告进程调度算法Minix 操作系统实践计算机科学与技术题 目 :姓 名 : 学 号 : 专业 : 指导教师 :实验一1．实验目的通过优先权法和轮转算法的模拟加深对进程概念和进程调度过程的理解，掌握进程状态之间的切换，同时掌握进程调度算法的实现方法和技巧。
2．实验内容1．用C++语言来实现对n 个进程采用优先权优先算法以及轮转算法的进程调度。
2．每个用来标识进程的进程控制块PCB 用结构来描述，包括以下字段：（1）进程标识ID，其中0 为闲逛进程，用户进程的标识数为1，2，3⋯。
（2）进程优先级Priority ，闲逛进程（idle）的优先级为0，用户进程的优先级大于0，且随机产生，标识数越大，优先级越高。
（3）进程占用的CPU时间CPUtime，进程每运行一次，累计值等于4。
（4）进程总共需要运行时间Alltime ，利用随机函数产生。
（5）进程状态，0－就绪态；1－运行态；2－阻塞态。
（6）队列指针next，用来将多个进程控制块PCB 链接为队列。
3．优先数改变的原则（1）进程在就绪队列中每呆一个时间片，优先数增加1。
（2）进程每运行一个时间片，优先数减3。
4．在调度前，系统中拥有的进程数PCB_number 由键盘输入，经初始化后，所有的进程控制块PCB 链接成就绪队列。
5．为了清楚地观察诸进程的调度过程，程序应将每个时间片内的进程的情况显示出来，3．实验步骤进程调度的思想（1）当系统空闲（就绪队列为空）时，系统运行闲逛进程，否则运行其他进程，发生变迁1（就绪→运行）。
（2）在运行进程（包括闲逛进程）的过程中，可能发生变迁2（运行→阻塞），即将运行进程插入到阻塞队列（闲逛进程不能被阻塞），可能有其他新的进程创建PCB，还可能唤醒阻塞队列中的某些进程PCB，发生变迁3（阻塞→就绪），即从阻塞队列中移出并插入就绪队列中。
（3）时间片运行结束后，若进程累计占用CPU 时间大于等于进程需要运行的时间，则进程执行结束，释放其PCB。
操作系统课程设计报告进程调度算法
操作系统课程设计报告进程调度算法Minix 操作系统实践计算机科学与技术题 目 :姓 名 : 学 号 : 专业 : 指导教师 :实验一1．实验目的通过优先权法和轮转算法的模拟加深对进程概念和进程调度过程的理解，掌握进程状态之间的切换，同时掌握进程调度算法的实现方法和技巧。
2．实验内容1．用C++语言来实现对n 个进程采用优先权优先算法以及轮转算法的进程调度。
2．每个用来标识进程的进程控制块PCB 用结构来描述，包括以下字段：（1）进程标识ID，其中0 为闲逛进程，用户进程的标识数为1，2，3⋯。
（2）进程优先级Priority ，闲逛进程（idle）的优先级为0，用户进程的优先级大于0，且随机产生，标识数越大，优先级越高。
（3）进程占用的CPU时间CPUtime，进程每运行一次，累计值等于4。
（4）进程总共需要运行时间Alltime ，利用随机函数产生。
（5）进程状态，0－就绪态；1－运行态；2－阻塞态。
（6）队列指针next，用来将多个进程控制块PCB 链接为队列。
3．优先数改变的原则（1）进程在就绪队列中每呆一个时间片，优先数增加1。
（2）进程每运行一个时间片，优先数减3。
4．在调度前，系统中拥有的进程数PCB_number 由键盘输入，经初始化后，所有的进程控制块PCB 链接成就绪队列。
5．为了清楚地观察诸进程的调度过程，程序应将每个时间片内的进程的情况显示出来，3．实验步骤进程调度的思想（1）当系统空闲（就绪队列为空）时，系统运行闲逛进程，否则运行其他进程，发生变迁1（就绪→运行）。
（2）在运行进程（包括闲逛进程）的过程中，可能发生变迁2（运行→阻塞），即将运行进程插入到阻塞队列（闲逛进程不能被阻塞），可能有其他新的进程创建PCB，还可能唤醒阻塞队列中的某些进程PCB，发生变迁3（阻塞→就绪），即从阻塞队列中移出并插入就绪队列中。
（3）时间片运行结束后，若进程累计占用CPU 时间大于等于进程需要运行的时间，则进程执行结束，释放其PCB。
操作系统课程设计报告进程调度算法模拟大学论文
1．课程设计的目的《操作系统原理》课程设计我们专业实践性环节之一，是学习完《操作系统原理》课程后进行的一次较全面的综合练习。
其目的在于加深对操作系统的理论、方法和基础知识的理解，掌握操作系统结构、实现机理和各种典型算法，系统地了解操作系统的设计和实现思路，培养学生的系统设计能力，并了解操作系统的发展动向和趋势。
2．课程设计的内容及要求先来先服务、短作业优先、时间片轮转、基于静态优先级的调度，基于高响应比优先的动态优先级调度算法实现，能够输出调度情况，并计算周转时间和平均周转时间。
要求使用链表，进程个数由用户提供，按照进程的实际个数生成PCB，程序能够让用户选择使用哪种调度算法，能够在Linux环境运行并验证结果。
程序要考虑用户界面的友好性和使用方便性。
进程基本信息可从文件读入，也可手动输入。
3、设计原理3.1先来先服务调度算法每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源创建进程，然后放入就绪队列3.2短作业优先调度算法短作业优先调度算法是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再重新调度。
3.3时间片轮转调度算法系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。
时间片的大小从几ms到几百ms。
当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。
3.4静态优先级调度算法把处理机分配给优先级最高的进程，使之执行。
但在其执行期间，只要出现了另一个比其优先级更高的进程，调度程序就将处理机分配给新到的优先级最高的进程。
这样就可以保证紧迫性作业优先运行。
3.5最高响应比优先的动态优先级调度算法优先权调度算法是为了照顾紧迫型作业，使之在进入系统后便获得优先处理，引入最高优先权优先调度算法。
操作系统进程调度模拟程序实验报告
目录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算法根据进程的优先级进行调度，优先级高的进程优先执行。
具体实现如下：- 设置一个优先级阈值，当进程的优先级高于阈值时，将其加入就绪队列。
- 遍历就绪队列，选择优先级最高的进程执行，直到进程完成或被阻塞。
操作系统课程设计报告模拟进程调度程序(一)
操作系统课程设计报告模拟进程调度程序(一) 此设计报告是对操作系统中进程调度的两种算法，即静态优先权调度算法和需要时间片的转法进行了描述，并分析了它们的工作机理。
最高优先权调度算法的基本思想是把CPU分配给就绪队列中优先权最高的进程。
静态优先数是在创建进程时确定的，并在整个进程运行期间不再改变。
简单轮转法的基本思想是：所有就绪进程按FCFS排成一个队列，总是把处理机分配给队首的进程，各进程占用CPU的时间片相同。
如果运行进程用完它的时间片后还未完成，就把它送回到就绪队列的末尾，把处理机重新分配给队首的进程，直至所有的进程运行完毕。
然后用具体语言模拟了一个进程调度的程序。
用户可以自己输入产生进程，然后选择调度方式进行调度。
所用的语言为，结果显示了调度运行过程。
问题描述和分析………………………………………………4算法设计............................................................5源代码及说明.........................................................5结果与分析...............................................................17参考文献 (18)一、问题描述和分析问题描述CPU调度是多道程序操作系统的基础，几乎所有计算机资源在使用前都要被调度，因此，CPU调度对于操作系统来说非常重要。
假如操作系统中存在若干进程，这些进程，将会被按照指定的调度方式，由CPU进行调度。
本程序，用来模拟实现操作系统中的两种调度方法，即：优先权调度和轮转法调度。
下面对四种调度方法进行描述优先权调度（priority-schedulingalgorithm）：在这种方式下，每一个进程都有一个优先权与其关联，具有最高优先权的进程会被分配到CPU，具有相同优先权的进程按FCFS顺序调度。
操作系统进程调度算法模拟
实验一进程调度算法模拟一.实验题目：设计一个简单的进程调度算法，模拟OS中的进程调度过程二．要求：①进程数不少于5个；②进程调度算法任选；可以用动态优先数加时间片轮转法实现进程调度，每运行一个时间片优先数减3；③用C语言编程；④程序运行时显示进程调度过程。
三．程序中所用数据结构及说明:进程控制块结构体：typedef struct node1{int ID;//进程标识数int PRIORITY;//进程优先数int CPUTIME;//进程已占用时间片int ALLTIME;//进程还需占用时间片}Block,pcb;就绪进程链表节点：typedef struct node2{pcb data;struct node2 *next;}process;四．清单程序及描述：Procelink.h:typedef struct node1{int ID;//进程标识数int PRIORITY;//进程优先数int CPUTIME;//进程已占用时间片int ALLTIME;//进程还需占用时间片//char STATE;//进程状态//struct node *next;//进程队列指针}Block,pcb;typedef struct node2{pcb data;struct node2 *next;}process;void Initlink(process **PQ){/*如果有内存空间，申请头结点空间并使头指针head指向头结点*/if((*PQ = (process *)malloc(sizeof(process))) == NULL) exit(1);(*PQ)->next = NULL; /*置链尾标记NULL */}int IsEmpty(process *PQ){if(PQ->next == NULL)return 1;else return 0;}void EnInitlink(process *PQ,pcb p){while(PQ->next!=NULL) PQ=PQ->next;process *temp=(process *)malloc(sizeof(Block));temp->data.PRIORITY=p.PRIORITY;temp->data.ID=p.ID;temp->data.CPUTIME=p.CPUTIME;temp->data.ALLTIME=p.ALLTIME;temp->next=PQ->next;PQ->next=temp;}//插入pcb DeInitlink(process *PQ) //选择优先数最小的出列{if(IsEmpty(PQ)){printf("所有进程已运行完!\n");exit(0);//退出}process *temp=(process *)malloc(sizeof(Block));temp = PQ->next;process *te=(process *)malloc(sizeof(Block));process *t=(process *)malloc(sizeof(Block));te= PQ->next;//优先数最小的进程while(temp->next != NULL){if(te->data.PRIORITY<temp->next->data.PRIORITY){te=temp->next;t=temp->next->next;PQ=temp;}temp=temp->next;}PQ->next=PQ->next->next;pcb pp=te->data;// free(temp);// free(t);//free(te);return pp;}//出队列void outid(process *PQ)//输出就绪队列函数{ printf("当前就绪队列为: ");while(!IsEmpty(PQ)){printf("%d ",PQ->next->data.ID);PQ=PQ->next;}printf("\n");}void dispatch(pcb p,process *PQ)//进程运行函数{if((p.ALLTIME)!=0){p.PRIORITY-=3;p.CPUTIME+=1;p.ALLTIME-=1;printf("进程%d运行\n",p.ID);//printf("进程优先数：%d 进程已占用时间片：%d 进程还需占用时间片：%d\n",p.PRIORITY,p.CPUTIME,p.ALLTIME);outid(PQ);//输出就绪队列}if((p.ALLTIME)==0){printf("进程%d 运行完成!\n",p.ID);return;//完成则不加入链表}EnInitlink(PQ,p); return;//运行之后再加入链表}os_1.cpp:#include<stdio.h>#include<stdlib.h>#include"procelink.h"void main(){process * PQ;int n;//n为进程数pcb pro1;Initlink(& PQ);printf("请输入进程个数：");scanf("%d",&n);printf("请输入各个进程的进程标识数ID,进程优先数，进程已占用时间片，进程还需占用时间片\n");for(int i=1;i<=n;i++){printf("第%d进程: ",i);scanf("%d %d %d %d",&pro1.ID,&pro1.PRIORITY,&pro1.CPUTIME,&pro1.ALLTIME);EnInitlink(PQ,pro1);}while(!IsEmpty(PQ)){dispatch(DeInitlink(PQ),PQ);//进程运行函数调用}if(IsEmpty(PQ))printf("所有进程已运行完!\n");free(PQ);//释放内存空间}五．执行结果：六．实验总结：通过这次操作系统中进程调度算法的模拟，使我对操作系统中的进程调度有了更清晰的认识和了解，程序中也有不足之处，该程序是顺序进链，出链时再选择优先数最大的进程。
进程调度模拟程序实验实验报告
进程调度模拟程序实验实验报告一、实验目的进程调度是操作系统的核心功能之一，它负责合理地分配 CPU 资源给各个进程，以提高系统的性能和效率。
本次实验的目的是通过编写和模拟进程调度程序，深入理解不同的进程调度算法的原理和特点，并比较它们在不同情况下的性能表现。
二、实验环境本次实验使用的编程语言为 Python，开发环境为 PyCharm。
操作系统为 Windows 10。
三、实验原理1、先来先服务（FCFS）调度算法先来先服务调度算法按照进程到达的先后顺序进行调度，先到达的进程先获得 CPU 资源。
2、短作业优先（SJF）调度算法短作业优先调度算法优先调度执行时间短的进程。
3、时间片轮转（RR）调度算法时间片轮转调度算法将 CPU 时间划分为固定大小的时间片，每个进程轮流获得一个时间片的 CPU 资源。
四、实验设计1、进程类的设计创建一个进程类，包含进程 ID、到达时间、服务时间、剩余服务时间等属性，以及用于更新剩余服务时间和判断进程是否完成的方法。
2、调度算法实现分别实现先来先服务、短作业优先和时间片轮转三种调度算法。
3、模拟流程（1）初始化进程列表。
（2）按照选定的调度算法进行进程调度。
（3）计算每个进程的等待时间、周转时间等性能指标。
五、实验步骤1、定义进程类｀｀｀pythonclass Process:def ＿_init__(self, pid, arrival_time, service_time)：selfpid ＝ pidselfarrival_time ＝ arrival_timeselfservice_time ＝ service_timeselfremaining_service_time ＝ service_time｀｀｀2、先来先服务调度算法实现｀｀｀pythondef fcfs_scheduling(process_list)：current_time ＝ 0total_waiting_time ＝ 0total_turnaround_time ＝ 0for process in process_list:if current_time ＜ processarrival_time:current_time ＝ processarrival_timewaiting_time ＝ current_time processarrival_timetotal_waiting_time ＋＝ waiting_timecurrent_time ＋＝ processservice_timeturnaround_time ＝ current_time processarrival_timetotal_turnaround_time ＋＝ turnaround_timeaverage_waiting_time ＝ total_waiting_time ／ len(process_list)average_turnaround_time ＝ total_turnaround_time ／ len(process_list) print(＂先来先服务调度算法的平均等待时间：＂，average_waiting_time)print(＂先来先服务调度算法的平均周转时间：＂，average_turnaround_time)｀｀｀3、短作业优先调度算法实现｀｀｀pythondef sjf_scheduling(process_list)：current_time ＝ 0total_waiting_time ＝ 0total_turnaround_time ＝ 0sorted_process_list ＝ sorted(process_list, key=lambda x: xservice_time) for process in sorted_process_list:if current_time ＜ processarrival_time:current_time ＝ processarrival_timewaiting_time ＝ current_time processarrival_timetotal_waiting_time ＋＝ waiting_timecurrent_time ＋＝ processservice_timeturnaround_time ＝ current_time processarrival_timetotal_turnaround_time ＋＝ turnaround_timeaverage_waiting_time ＝ total_waiting_time ／ len(process_list)average_turnaround_time ＝ total_turnaround_time ／ len(process_list) print(＂短作业优先调度算法的平均等待时间：＂，average_waiting_time)print(＂短作业优先调度算法的平均周转时间：＂，average_turnaround_time)｀｀｀4、时间片轮转调度算法实现｀｀｀pythondef rr_scheduling(process_list, time_slice)：current_time ＝ 0total_waiting_time ＝ 0total_turnaround_time ＝ 0ready_queue ＝while len(process_list) ＞ 0 or len(ready_queue) ＞ 0:for process in process_list:if processarrival_time ＜＝ current_time:ready_queueappend(process)process_listremove(process)if len(ready_queue) ＝＝ 0:current_time ＋＝ 1continueprocess ＝ ready_queuepop(0)if processremaining_service_time ＜＝ time_slice: waiting_time ＝ current_time processarrival_time total_waiting_time ＋＝ waiting_timecurrent_time ＋＝ processremaining_service_time turnaround_time ＝ current_time processarrival_time total_turnaround_time ＋＝ turnaround_time processremaining_service_time ＝ 0else:waiting_time ＝ current_time processarrival_time total_waiting_time ＋＝ waiting_timecurrent_time ＋＝ time_sliceprocessremaining_service_time ＝ time_sliceready_queueappend(process)average_waiting_time ＝ total_waiting_time ／ len(process_list)average_turnaround_time ＝ total_turnaround_time ／ len(process_list) print(＂时间片轮转调度算法（时间片大小为"， time_slice, ＂）的平均等待时间：＂， average_waiting_time)print(＂时间片轮转调度算法（时间片大小为"， time_slice, ＂）的平均周转时间：＂， average_turnaround_time)｀｀｀5、主函数｀｀｀pythonif ＿_name__ ＝＝＂＿_main__"：process_list ＝Process(1, 0, 5)，Process(2, 1, 3)，Process(3, 2, 8)，Process(4, 3, 6)print(＂先来先服务调度算法：＂）fcfs_scheduling(process_list)print(＂短作业优先调度算法：＂）sjf_scheduling(process_list)time_slice ＝ 2print(＂时间片轮转调度算法（时间片大小为"，time_slice, ＂）：＂）rr_scheduling(process_list, time_slice)｀｀｀六、实验结果与分析1、先来先服务调度算法平均等待时间为 575，平均周转时间为 1275。
操作系统课程设计——进程调度模拟算法(5种)
福建农林大学计算机与信息学院课程设计报告课程名称：操作系统实习题目：进程调度算法模拟姓名：***系：计算机专业：计算机科学与技术年级：2011级学号：**指导教师：***职称：***2014年1月16日福建农林大学计算机与信息学院信息工程类课程设计报告结果评定目录1.进程调度算法模拟课程设计的目的 (1)2.进程调度算法模拟课程设计的要求 (1)3.进程调度算法模拟课程设计报告内容 (1)3．1前言 (1)3．2进程调度算法模拟设计的环境 (1)3．3系统流程图及各模块 (2)4．总结 (18)参考文献 (19)参考网站 (19)进程调度算法模拟1.进程调度算法模拟课程设计的目的和意义2013-2014学年，在学习了《操作系统》这门课后，对当中的进程调度算法产生了浓厚的兴趣。
各种调度算法，理论上比较好理解。
为了加深印象，我决定把各种调度算法用C语言写出来。
于是便产生这份从头到尾都让我绞尽脑汁的课程设计。
做这份课程设计，对从事系统开发的人员来说，是必要的，可以在一定程度上为自己以后的发展铺路。
虽然用处不是特别明显，但对加深系统调用算法的理解无疑用处是巨大的。
2.进程调度算法模拟课程设计的要求1.用C语言写出至少两种进程调度算法。
2.画出大概流程图。
3.对算法过程出现的bug进行调试。
4.展示最后的算法结果3.1前言：目前比较常见的几种进程调度算法有：1.先到先服务(FCFS)2.短进程优先（非抢占和抢占）算法(SPF)3.高响应比优先算法4.时间片轮转算法我选出其中三种即先到先服务，短进程优先（2种）和时间片轮转算法进行C语言描述以加深对这三种算法的理解。
3.2进程调度算法模拟设计的环境VC++6.0及CodeBlocks，32位计算机WIN7操作系统。
3.3流程图定义进程结构体：struct Pro{int num; //进程号int time_in; //进程到达时间int work_time; //进程服务时间int btime;//用于抢占式进程优先记录该进程开始时间int l_w_time;//用于抢占式进程优先记录剩余服务时间int end_time; //记录该进程结束时间，（需要时时监测）int judge; //用于需要时的标记}pro[10]; //进程结构体1先到先服务算法描述：把所有进程按到达先后排序，每次取最先到的进程执行后淘汰，再取下一个，直到所有进程调度完毕。
进程调度算法模拟实验报告
竭诚为您提供优质文档/双击可除进程调度算法模拟实验报告篇一：操作系统进程调度算法模拟实验报告进程调度算法模拟专业：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;//是否在运行标志。
操作系统进程调度模拟程序实验报告
操作系统进程调度模拟程序实验报告一、实验目的本次实验旨在通过编写一个模拟操作系统进程调度的程序，以加深对进程调度算法的理解。
二、实验内容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)。
1．课程设计的目的《操作系统原理》课程设计我们专业实践性环节之一，是学习完《操作系统原理》课程后进行的一次较全面的综合练习。
其目的在于加深对操作系统的理论、方法和基础知识的理解，掌握操作系统结构、实现机理和各种典型算法，系统地了解操作系统的设计和实现思路，培养学生的系统设计能力，并了解操作系统的发展动向和趋势。
2．课程设计的内容及要求先来先服务、短作业优先、时间片轮转、基于静态优先级的调度，基于高响应比优先的动态优先级调度算法实现，能够输出调度情况，并计算周转时间和平均周转时间。
要求使用链表，进程个数由用户提供，按照进程的实际个数生成PCB，程序能够让用户选择使用哪种调度算法，能够在Linux环境运行并验证结果。
程序要考虑用户界面的友好性和使用方便性。
进程基本信息可从文件读入，也可手动输入。
3、设计原理3.1先来先服务调度算法每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源创建进程，然后放入就绪队列3.2短作业优先调度算法短作业优先调度算法是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再重新调度。
3.3时间片轮转调度算法系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。
时间片的大小从几ms到几百ms。
当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。
3.4静态优先级调度算法把处理机分配给优先级最高的进程，使之执行。
但在其执行期间，只要出现了另一个比其优先级更高的进程，调度程序就将处理机分配给新到的优先级最高的进程。
这样就可以保证紧迫性作业优先运行。
3.5最高响应比优先的动态优先级调度算法优先权调度算法是为了照顾紧迫型作业，使之在进入系统后便获得优先处理，引入最高优先权优先调度算法。
动态优先权是指在创建进程时所赋予的优先权，是可以随进程的推进或随其等待时间的增加而改变的，以便获得更好的调度性能。
4．设计说明4.1结构设计(1) 菜单选择模块。
选择相应的进程调度方式，选择相应的数字，进入相应的功能。
(2) 调度算法模块。
选择相应的进程调度算法。
(3) 显现输出模块。
显示每种进程调度算法情况。
(4) 平均周转时间与平均带权周转时间的计算结果。
(5) 退出系统模块。
4.2功能设计（1）菜单选择模块设计方案：首先将各种进程调度算法放入不同的头文件，在主函数引用，是系统结构更加清晰。
实现方法：设置一个menu()方法，让用户选择不同的进程调度算法，menu()方法返回一个char类型字符，以便在主函数的switch语句中选择调用不同的进程调度方法。
（2）调度算法模块A、先来先服务调度算法设计方案：对于先到达的进程优先分配CPU，按照先来先服务的原则依次执行各进程。
实现方法：每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源创建进程，然后放入就绪队列B、短作业优先调度算法设计方案：短作业优先调度算法是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再重新调度。
实现方法：先找到运行时间最短的程序，然后执行，再从剩余的程序中找到运行时间最短的在执行，依次每次都执行运行时间最短的，直到程序执行完毕。
C、时间片轮转调度算法设计方案：系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。
时间片的大小从几ms到几百ms。
当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。
实现方法：按照轮转的次序分配给每个程序一定的时间执行，执行完成后执行后面的进程，依次循环执行直到所有进程执行完成。
D、静态优先级调度算法设计方案：把处理机分配给优先级最高的进程，使之执行。
但在其执行期间，只要出现了另一个比其优先级更高的进程，调度程序就将处理机分配给新到的优先级最高的进程。
这样就可以保证紧迫性作业优先运行。
实现方法：按照优先级从高到低依次执行程序。
E、最高响应比优先的动态优先级调度算法设计方案：优先权调度算法是为了照顾紧迫型作业，使之在进入系统后便获得优先处理，引入最高优先权优先调度算法。
动态优先权是指在创建进程时所赋予的优先权，是可以随进程的推进或随其等待时间的增加而改变的，以便获得更好的调度性能。
实现方法：按照优先级从高到低依次执行程序。
（3）平均周转时间与平均带权周转时间的计算设计方案：周转时间=完成时间-到达时间带权周转时间=周转时间/服务时间平均周转时间=总的周转时间/进程个数平均带权周转时间=总的带权周转时间/进程个数实现方法：系统自行根据程序及输入的数据计算出平均周转时间和平均带权周转时4.3程序中使用的数据结构及使用的变量说明和作用（1）结构体/***先来先服务调度算法结构体***/struct fcfs{char name[10]; //作业名float arrivetime; //作业到达时间float servicetime; //作业服务时间float starttime; //作业开始时间float finishtime; //作业完成时间float zztime; //周转时间float dqzztime; //带权周转时间};/***短作业优先调度算法结构体***/struct jcb //作业控制块JCB,定义为结构体{char name[10]; //作业名float arrivetime; //作业到达时间float servicetime;//作业服务时间float finishtime; //作业完成时间float zztime; //周转时间float dqzztime; //带权周转时间};/***时间片轮转调度算法结构体***/struct rr{ //定义时间片轮转调度算法结构体，里面包含得有一个进程相关的信息char name[10]; //作业名float arrivetime; //作业到达时间float servicetime; //作业服务时间float starttime; //作业开始时间float finishtime; //作业结束时间float zztime; //作业周转时间float dqzztime; //作业带权周转时间float avzztime; //作业平均周转时间float avdqzztime; //作业平均带权周转时间float lefttime; //剩余时间float stoptime; //停止时间int timeprice; //时间片设置的大小};/***静态优先级调度算法结构体***/struct sp {char name[10]; //作业号float arrivetime; //作业到达时间float servicetime; //服务时间float waittime; //等待时间float starttime; //开始运行时间float finishtime; //结束运行时间float zztime; //周转时间float dqzztime; //带权周转时间float priority; //优先权float finish; //是否已经完成}sta[10];//作业控制块，这是一个结构体数组/***最高响应比调度算法结构体***/struct task {char name[10]; //作业号float arrivetime; //作业到达时间float servicetime; //服务时间float waittime; //等待时间float finishtime; //结束运行时间float zztime; //周转时间float dqzztime; //带权周转时间float priority; //优先权float finish; //是否已经完成}JCB[10];//作业控制块，这是一个结构体数组（2）基本变量char name[10]; //作业名float arrivetime; //作业到达时间float servicetime; //作业服务时间float starttime; //作业开始时间float finishtime; //作业完成时间float zztime; //周转时间float dqzztime; //带权周转时间float avzztime; //作业平均周转时间float avdqzztime; //作业平均带权周转时间float lefttime; //剩余时间float stoptime; //停止时间int timeprice; //时间片设置的大小float priority; //优先权float finish; //是否已经完成5．具体实现5.1菜单选择模块（1）功能说明按照工作台提示，选择调度算法。
（2）函数实现过程（3）关键程序char Menu()//用来输出相关信息的函数{char choice;//用户选择while(1){system("cls");//清屏fflush(stdin);//清空缓存cout<<endl;cout<<endl;cout<<endl;cout<<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"<<" "<<"\t*\t 3.时间片轮转调度算法"<<"\t\t*\t"<<" "<<endl;cout<<"\t"<<" "<<endl;cout<<"\t"<<" "<<"\t*\t 4.静态优先级调度算法"<<"\t\t*\t"<<" "<<endl;cout<<"\t"<<" "<<endl;cout<<"\t"<<" "<<"\t*\t 5.最高响应比优先调度算法"<<"\t*\t"<<" "<<endl;cout<<"\t"<<" "<<endl;cout<<"\t"<<" "<<"\t*\t 0.退出系统"<<"\t*\t"<<" "<<endl;cout<<"\t"<<""<<"\t*****************************************"<<"\t\t"<<" "<<endl;cout<<endl;cout<<"\t\t 请输入您的选择(0/1/2/3/4/5)："<<endl;choice=getchar();if(choice<'0'||choice>'5')//若输入有误{cout<<endl;cout<<"您的输入有误!请重新输入正确的字符! "<<endl;cout<<endl;system("PAUSE");//输出“按任意键继续”，等待用户按一个键，然后返回主菜单}elsebreak;}return choice;}5.2调度算法模块（1）先来先服务调度算法a、功能说明按照先来先服务原则调度用户输入的进程b、函数实现过程c、关键程序void DealByFCFS(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)//进程个数为1{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){float sumzztime=0, sumdqzztime=0, avzztime, avdqzztime;//总的周转时间、总的带权周转时间、平均周转时间、平均带权周转时间float arrivetime=0, servicetime=0, starttime=0, finishtime=0, zztime=0, dqzztime=0;Sort(p,N);//按进程的到达时间进行排序（参数为存放进程的数组和进程个数）DealByFCFS(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);//运行阶段,根据先来先服务的原则进行处理Print(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N); //屏幕输出处理for(int k=0; k<=N-1; k++){sumzztime=sumzztime+p[k].zztime;//总的周转时间=前一个作业的周转时间+本次作业的周转时间（循环加）sumdqzztime=sumdqzztime+ p[k].dqzztime;//总的带权周转时间=前一个作业的带权周转时间+本次作业的带权周转时间（循环加）}avzztime=sumzztime/N;//平均周转时间=总的周转时间/进程个数printf("**\n");printf("*该算法的平均周转时间为:%-.2f\t",avzztime);avdqzztime= sumdqzztime/N; //平均带权周转时间=总的带权周转时间/进程个数printf("该算法的平均带权周转时间为:%-.2f\t *",avdqzztime);printf("\n***************************************************************** **************\n ");}（2）短作业优先调度算法a、功能说明按照短作业优先原则调度用户输入的进程b、函数实现过程c、关键程序void DealBySJF(jcb *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)//进程个数为1{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 SJF(jcb *p,int N) //短作业优先调度算法处理过程{float sumzztime=0, sumdqzztime=0,avzztime,avdqzztime;//总的周转时间、总的带权周转时间、平均周转时间、平均带权周转时间float arrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0;Sort(p,N); //按进程的到达时间进行排序（参数为存放作业的数组和作业个数）for(int m=0; m<N-1; m++){if(m==0) //进程个数为0p[m].finishtime=p[m].arrivetime+p[m].servicetime; //完成时间=到达时间+服务时间elsep[m].finishtime=p[m-1].finishtime+p[m].servicetime; //完成时间=前一个作业的完成时间+服务时间int i=0;for(int n=m+1;n<=N-1;n++){if(p[n].arrivetime<=p[m].finishtime) //找出服务时间较短的作业的个数ii++;}float min=p[m+1].servicetime;//min为服务时间最短的作业，先将服务时间较短的作业队列中的第一个付给minint next=m+1;//m+1=n ，next为服务时间最短的作业序号for(int k=m+1;k<m+i;k++) //在i个服务时间较短的作业队列中找出服务时间最短的作业{if(p[k+1].servicetime<min) //再从剩余的作业中找出运行时间最短的，从队列中第二个作业开始比较{min=p[k+1].servicetime; //第k+1个作业为新的服务时间最短的作业next=k+1;}}jcb temp;//第m+1个作业的服务时间小于第k+1个，所以交换顺序temp=p[m+1];p[m+1]=p[next];p[next]=temp;}//找到了服务时间最短的作业后DealBySJF(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);//按短作业优先原则进行进程服务处理Print(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);//屏幕输出处理for(int k=0; k<=N-1; k++){sumzztime=sumzztime+p[k].zztime;//总的周转时间=前一个作业的周转时间+本次作业的周转时间（循环加）sumdqzztime=sumdqzztime+ p[k].dqzztime;//总的带权周转时间=前一个作业的带权周转时间+本次作业的带权周转时间（循环加）}avzztime=sumzztime/N;//平均周转时间=总的周转时间/进程个数printf("**\n");printf("*该算法的平均周转时间为:%-.2f\t",avzztime);avdqzztime= sumdqzztime/N; //平均带权周转时间=总的带权周转时间/进程个数printf("该算法的平均带权周转时间为:%-.2f\t *",avdqzztime);printf("\n***************************************************************** **************\n ");getchar();//此处必须要有这个函数，否则就看不到显示器上面的输出，可以看到的结果只是一闪而过的一个框剪}（3）时间片轮转调度算法a、功能说明按照时间片轮转原则调度用户输入的进程b、函数实现过程c 、关键程序 void Print(rr *p,float arrivetime,float servicetime,float starttime,float finishtime,floatzztime,float dqzztime,int N) //屏幕打印输出处理{int k;printf("*调用时间片轮转调度算法以后进程的调度顺序是: ");//输出进程调度顺序printf("%s",p[0].name); //输出第一个for(k=1;k<N;k++){printf("-->%s",p[k].name); //输出第2到第N}cout<<endl; printf("*具体的进程调度信息: *\n");printf("**\n");printf("* 进程名 到达时间 服务时间 开始时间 结束时间 周转时间 带权周转时间*\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 ptt(rr *p,float arrivetime,float servicetime,float starttime,float finishtime,floatzztime,float dqzztime,float avzztime,float avdqzztime,float lefttime,int timeprice,int N) //时间片设置处理与程序运行{float w=0;//记录作业的停止时间int c=0;float stoptime=0; printf("请输入时间片的值：");cin>>timeprice;Sort(p,N); //按进程的到达时间排序float d[20],h[20];//分别用在服务时间和开始时间for(int k=0; k<=N-1; k++){d[k]=p[k].servicetime;//将队首进程的服务时间赋给d[k]if(k==0) //进程个数为1{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;//完成时间=前一个作业的完成时间+服务时间}h[k]=p[k].starttime;//将队首进程的开始时间赋给d[k]p[k].lefttime=p[k].servicetime-timeprice;//作业的剩余时间=服务时间-时间片的大小if(p[k].lefttime>0)//剩余时间>0（服务时间>时间片大小）{c=c+1;//记录还未执行完的作业个数p[k].stoptime=p[k].starttime+timeprice;//停止时间=开始时间+时间片大小p[k].finishtime=p[k].stoptime;//完成时间=停止时间}else//剩余时间<=0（服务时间<=时间片大小）p[k].stoptime=p[k].finishtime;//停止时间=完成时间w=p[k].stoptime;//记录作业的停止时间}printf("\n***********************************结果如下************************************\n");printf("*第1轮进程调度信息: *\n");printf("**\n");printf("* 进程名到达时间服务时间开始时间停止时间剩余时间*\n");for(k=0; k<=N-1; k++){printf("*\t%s\t%-.2f\t %-.2f\t %-.2f\t %-.2f\t%-.2f\n",p[k].name,p[k].arriv etime, p[k].servicetime,p[k].starttime,p[k].stoptime,p[k].lefttime);}getchar();int i=2;//从第2轮开始，初值为2while(c>0)//还有未执行完的作业{printf("**");printf("\n*第%d 轮具体进程调度信息(时间片为%d ): *\n",i,timeprice);printf("**\n");printf("* 进程名服务时间开始时间停止时间剩余时间*\n");for(k=0;k<=N-1;k++){if(p[k].lefttime>0)//剩余时间>0（服务时间>时间片大小）{p[k].servicetime=p[k].lefttime;//本次的服务时间=运行一次过后的剩余时间p[k].starttime=w;//上一个作业的停止时间就是本次作业的开始时间p[k].finishtime=p[k].starttime+p[k].servicetime;//完成时间=开始时间+服务时间p[k].lefttime=p[k].servicetime-timeprice;//剩余时间=服务时间-时间片的大小if(p[k].lefttime>0)//若作业的剩余时间仍>0（服务时间仍>时间片大小）p[k].stoptime=p[k].starttime+timeprice; //停止时间=开始时间+时间片的大小if(p[k].lefttime<=0)////剩余时间<=0（服务时间<=时间片大小）{c=c-1;//完成一个作业，c减1p[k].stoptime=p[k].finishtime;//停止时间=完成时间}w=p[k].stoptime;//记录作业的停止时间printf("*\t%s\t%-.2f\t %-.2f %-.2f %-.2f\n",p[k].name,p[k].servicetime,p[k].starttime,p[k].stoptime,p[k].lefttime);printf("**\n");}}i=i+1;}if(c<=0)//所有作业调度完毕printf("\n*时间片轮转调度过程结束！*\n");printf("**");for(k=0;k<=N-1;k++) //记录信息{p[k].servicetime=d[k];//服务时间p[k].starttime=h[k];//开始时间p[k].zztime=p[k].finishtime-p[k].arrivetime;//周转时间=完成时间-到达时间p[k].dqzztime=p[k].zztime/p[k].servicetime; //带权周转时间=周转时间/服务时间}}void tt(rr *p,int N){float sumzztime=0, sumdqzztime=0, avzztime=0, avdqzztime=0;//总的周转时间、总的带权周转时间、平均周转时间、平均带权周转时间int timeprice=0;//时间片大小floatarrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0,lefttime=0;ptt(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,avzztime,avdqzztime ,lefttime,timeprice,N);//时间片设置处理与程序运行printf("\n*综合信息为：*\n");Print(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);//屏幕打印输出处理for(int k=0;k<=N-1;k++){sumzztime=sumzztime+p[k].zztime;//总的周转时间=前一个作业的周转时间+本次作业的周转时间（循环加）sumdqzztime=sumdqzztime+ p[k].dqzztime;//总的带权周转时间=前一个作业的带权周转时间+本次作业的带权周转时间（循环加）}avzztime=sumzztime/N;//平均周转时间=总的周转时间/进程数printf("**\n");printf("*该算法的平均周转时间为:%-.2f\t",avzztime);avdqzztime= sumdqzztime/N;//平均带权周转时间=总的带权周转时间/进程数printf("该算法的平均带权周转时间为:%-.2f\t *",avdqzztime);printf("\n************************************************************* ******************\n ");getchar();}（4）静态优先级调度算法a、功能说明按照优先级调度原则调度用户输入的进程bc、关键程序int prio(int pre) //设置优先权//优先权=(等待时间+服务时间)/服务时间{int current=1,i,j;//current为当前作业for(i=0; i<N1; i++){sta[i].waittime=sta[pre].finishtime-sta[i].arrivetime; //等待时间=上一个作业的完成时间-到达时间sta[i].priority=(sta[i].waittime+sta[i].servicetime)/sta[i].servicetime;//优先权=(等待时间+服务时间)/服务时间}for(i=0; i<N1; i++){if(!sta[i].finish)//未完成{current=i; //找到第一个还没完成的作业break;}}for(j=i; j<N1; j++) //第一个还未完成的作业和后面的作业比较{if(!sta[j].finish) //还没完成(运行){if(sta[current].arrivetime<=sta[pre].finishtime) //如果作业在上一个作业完成之前到达{if(sta[j].arrivetime<=sta[pre].finishtime && sta[j].priority>sta[current].priority )current=j;// 找出到达时间在上一个作业完成之前，优先权高的作业}else //如果作业是在上一个作业完成之后到达{if(sta[j].arrivetime<sta[current].arrivetime)current=j; //找出比较早到达的一个if(sta[j].arrivetime==sta[current].arrivetime) //如果同时到达if(sta[j].priority>sta[current].priority)current=j; //找出优先权高的一个作业，即服务时间比较短的一个//优先权=(等待时间+服务时间)/服务时间}}}return current;//返回当前作业}void run(int i, int n, int pre, int staTime, int endTime){if(n==0)//进程个数为1{sta[i].starttime=sta[i].arrivetime; //开始时间=到达时间sta[i].finishtime=sta[i].starttime+sta[i].servicetime; //完成时间=到达时间+服务时间sta[i].zztime=sta[i].servicetime;//周转时间=服务时间sta[i].dqzztime=1.0;staTime=sta[i].starttime;//记录开始时间}else{if(sta[i].arrivetime>sta[pre].finishtime)//如果作业在上一个作业完成之后到达sta[i].starttime=sta[i].arrivetime; //开始时间=到达时间else//如果作业在上一个作业完成之前到达sta[i].starttime=sta[pre].finishtime; //开始时间=上一个作业的结束时间sta[i].finishtime=sta[i].starttime+sta[i].servicetime;//完成时间=开始时间+服务时间sta[i].zztime=sta[i].finishtime-sta[i].arrivetime; //周转时间=完成时间-到达时间sta[i].dqzztime=sta[i].zztime/sta[i].servicetime; //带权周转时间=周转时间/服务时间}if(n==N1-1)//到最后一个作业endTime=sta[i].finishtime;//结束时间=最后一个作业完成的时间sta[i].finish=1;//完成！！！！}void print(int i,int n){if(n==0){printf("* 名称到达时间服务时间开始时间完成时间周转时间带权周转时间*\n");}printf("*%7s%7.1f%10.1f%10.1f%10.1f%11.1f%11.1f *\n",sta[i].name,sta[i].arrivetime,sta[i].servicetime,sta[i].starttime,sta[i].finishtime,sta[i].zztime,sta[i].dqzztime);printf("**\n");}void spsa( ){int i,k;float staTime, endTime, sumzztime=0.0, sumdqzztime=0.0, avzztime, avdqzztime;int current=0, n=0, pre=0;sta[pre].finishtime=0;for(i=0; i<N1; i++){sta[i].finish=0;//所有作业未完成}printf("\n***********************************结果如下************************************\n");printf("*调用短作业优先调度算法以后进程的调度顺序是:");//输出进程调度顺序printf("%s",sta[0].name);//输出第一个for(k=1;k<N1;k++){printf("-->%s",sta[k].name);//输出第2到第N}printf("\n");printf("*具体的进程调度信息是: *\n");printf("**\n");for(n=0; n<N1; n++){current=prio(pre);//设置优先权run(current, n, pre, staTime, endTime);//执行作业print(current, n);//输出进程信息pre=current;}for(i=0; i<N1; i++){sumzztime+=sta[i].zztime;//计算总的周转时间sumdqzztime+=sta[i].dqzztime;//计算总的带权周转时间}avzztime=sumzztime/N1;//平均周转时间=总的周转时间/进程个数avdqzztime=sumdqzztime/N1;//平均带权周转时间=总的带权周转时间/进程个数printf("*该算法的平均周转时间为:%-.2f\t",avzztime);printf("该算法的平均带权周转时间为:%-.2f\t *",avdqzztime);printf("\n************************************************************* ******************\n ");}（5）最高响应比动态优先级调度算法a、功能说明按照最高响应比优先原则调度用户输入的进程b、函数实现过程c、关键程序int HRN(int pre) //设置优先权//优先权=(等待时间+服务时间)/服务时间{int current=1,i,j;//current为当前作业for(i=0; i<N; i++){JCB[i].waittime=JCB[pre].finishtime-JCB[i].arrivetime; //等待时间=上一个作业的完成时间-到达时间JCB[i].priority=(JCB[i].waittime+JCB[i].servicetime)/JCB[i].servicetime;//优先权=(等待时间+服务时间)/服务时间}for(i=0; i<N; i++){if(!JCB[i].finish)//未完成{current=i; //找到第一个还没完成的作业break;}}for(j=i; j<N; j++) //第一个还未完成的作业和后面的作业比较{if(!JCB[j].finish) //还没完成(运行){if(JCB[current].arrivetime<=JCB[pre].finishtime) //如果作业在上一个作业完成之前到达{if(JCB[j].arrivetime<=JCB[pre].finishtime && JCB[j].priority>JCB[current].priority )current=j;// 找出到达时间在上一个作业完成之前，优先权高的作业}else //如果作业是在上一个作业完成之后到达{if(JCB[j].arrivetime<JCB[current].arrivetime)current=j; //找出比较早到达的一个if(JCB[j].arrivetime==JCB[current].arrivetime) //如果同时到达if(JCB[j].priority>JCB[current].priority)current=j; //找出优先权高的一个作业，即服务时间比较短的一个//优先权=(等待时间+服务时间)/服务时间}}}return current;//返回当前作业}void runing(int i, int n, int pre, int staTime, int endTime){if(n==0)//进程个数为1{JCB[i].starttime=JCB[i].arrivetime; //开始时间=到达时间JCB[i].finishtime=JCB[i].starttime+JCB[i].servicetime; //完成时间=到达时间+服务时间JCB[i].zztime=JCB[i].servicetime;//周转时间=服务时间JCB[i].dqzztime=1.0;staTime=JCB[i].starttime;//记录开始时间}else{if(JCB[i].arrivetime>JCB[pre].finishtime)//如果作业在上一个作业完成之后到达JCB[i].starttime=JCB[i].arrivetime; //开始时间=到达时间else//如果作业在上一个作业完成之前到达JCB[i].starttime=JCB[pre].finishtime; //开始时间=上一个作业的结束时间JCB[i].finishtime=JCB[i].starttime+JCB[i].servicetime;//完成时间=开始时间+服务时间JCB[i].zztime=JCB[i].finishtime-JCB[i].arrivetime; //周转时间=完成时间-到达时间JCB[i].dqzztime=JCB[i].zztime/JCB[i].servicetime; //带权周转时间=周转时间/服务时间}if(n==N-1)//到最后一个作业endTime=JCB[i].finishtime;//结束时间=最后一个作业完成的时间JCB[i].finish=1;//完成！！！！}void check( ){int i;float staTime, endTime, sumzztime=0.0, sumdqzztime=0.0, avzztime, avdqzztime;int current=0, n=0, pre=0;JCB[pre].finishtime=0;for(i=0; i<N; i++){JCB[i].finish=0;//所有作业未完成}printf("\n***********************************结果如下************************************\n");printf("*具体的进程调度信息是: *\n");printf("**\n");for(n=0; n<N; n++){current=HRN(pre);//设置优先权runing(current, n, pre, staTime, endTime);//执行作业Print(current, n);//输出进程信息pre=current;}for(i=0; i<N; i++){sumzztime+=JCB[i].zztime;//计算总的周转时间sumdqzztime+=JCB[i].dqzztime;//计算总的带权周转时间}avzztime=sumzztime/N;//平均周转时间=总的周转时间/进程个数avdqzztime=sumdqzztime/N;//平均带权周转时间=总的带权周转时间/进程个数printf("*该算法的平均周转时间为:%-.2f\t",avzztime);printf("该算法的平均带权周转时间为:%-.2f\t *",avdqzztime);printf("\n************************************************************* ******************\n ");}6．软件运行环境及限制VC++ 6.07．结果输出及分析7.1先来先服务调度算法（1）输入值（2）运行结果7.2短作业优先调度算法（1）输入值（2）运行结果7.3时间片轮转调度算法（1）输入值（2）运行结果7.4静态优先级调度算法 （1）输入值（2）运行结果7.5最高响应比动态优先级调度算法（1）输入值（2）运行结果8．心得体会经过一周的努力，课程设计基本完成了，这次课程设计培养了我们耐心、慎密、全面地考虑问题的能力，从而加快了问题解决的速度、提高了个人的工作效率，以及锻炼围绕问题在短时间内得以解决的顽强意志。