操作系统课程设计报告-进程调度算法模拟
(完整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。
- 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．心得体会经过一周的努力，课程设计基本完成了，这次课程设计培养了我们耐心、慎密、全面地考虑问题的能力，从而加快了问题解决的速度、提高了个人的工作效率，以及锻炼围绕问题在短时间内得以解决的顽强意志。