模拟进程调度功能的设计与实现操作系统课程设计(含源文件)
(完整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。
操作系统-进程调度模拟算法附源码)
进程调度模拟算法课程名称：计算机操作系统班级：信1501-2实验者姓名：李琛实验日期：2018年5月1日评分：教师签名：一、实验目的进程调度是处理机管理的核心内容。
本实验要求用高级语言编写模拟进程调度程序，以便加深理解有关进程控制快、进程队列等概念，并体会和了解优先数算法和时间片轮转算法的具体实施办法。
二、实验要求1.设计进程控制块PCB 的结构，通常应包括如下信息：进程名、进程优先数（或轮转时间片数）、进程已占用的CPU 时间、进程到完成还需要的时间、进程的状态、当前队列指针等。
2.编写两种调度算法程序：优先数调度算法程序循环轮转调度算法程序3.按要求输出结果。
三、实验过程分别用两种调度算法对伍个进程进行调度。
每个进程可有三种状态；执行状态（RUN）、就绪状态（READY,包括等待状态）和完成状态（FINISH），并假定初始状态为就绪状态。
（一）进程控制块结构如下：NAME——进程标示符PRIO/ROUND——进程优先数/进程每次轮转的时间片数（设为常数 2）CPUTIME——进程累计占用 CPU 的时间片数NEEDTIME——进程到完成还需要的时间片数STATE——进程状态NEXT——链指针注：1.为了便于处理，程序中进程的的运行时间以时间片为单位进行计算；2.各进程的优先数或轮转时间片数，以及进程运行时间片数的初值，均由用户在程序运行时给定。
（二）进程的就绪态和等待态均为链表结构，共有四个指针如下：RUN——当前运行进程指针READY——就需队列头指针TAIL——就需队列尾指针FINISH——完成队列头指针（三）程序说明1. 在优先数算法中，进程优先数的初值设为：50-NEEDTIME每执行一次，优先数减 1，CPU 时间片数加 1，进程还需要的时间片数减 1。
在轮转法中，采用固定时间片单位（两个时间片为一个单位），进程每轮转一次，CPU时间片数加 2，进程还需要的时间片数减 2，并退出 CPU，排到就绪队列尾，等待下一次调度。
操作系统课程设计报告---进程调度的模拟实现
操作系统课程设计报告专业计算机科学与技术学生姓名班级学号指导教师完成日期题目：进程调度的模拟实现的模拟实现一、设计目的本课程设计是学习完“操作系统原理”课程后进行的一次全面的综合训练，通过课程设计，更好地掌握操作系统的原理及实现方法，加深对操作系统基础理论和重要算法的理解，加强学生的动手能力。
在多道程序和多任务系统中，系统内同时处于就绪状态的进程可能有若干个。
也就是说能运行的进程数大于处理机个数。
为了使系统中的进程能有条不紊地工作，必须选用某种调度策略，选择一进程占用处理机。
要求学生设计一个模拟处理机调度算法，以巩固和加深处理机调度的概念。
二、设计内容1）概述选择一个调度算法，实现处理机调度。
设计要求：1）进程调度算法包括：时间片轮转法，短作业优先算法，动态优先级算法。
2）可选择进程数量3）本程序包括三种算法，用C或C++语言实现，执行时在主界面选择算法（可用函数实现），进入子页面后输入进程数，（运行时间，优先数由随机函数产生），执行，显示结果。
调度时总是选取优先数最大的进程优先运行2．每个进程的优先数，运行时间，由程序任意指定。
3．为了调度方便，把进程按给定优先级（动态优先级算法中）从小到大排成一个队列。
按给定运行时间（短作业优先）从小到大排成一个队列用一个变量作为队首指针，指向队列的第一个进程。
4．处理机调度总是选队首进程运行。
由于本实验是模拟处理机调度，所以被选中的进程并不实际的启动运行，而是执行：优先数-1（动态优先级算法中）要求运行时间-1来模拟进程的一次运行。
5．进程运行一次后，若要求运行时间不等于0，则再将它加入队列（动态优先级算法中：按优先数大小插入。
），且改变队首指针：若要求运行时间=0，则把它的状态改为完成（C）状态，且退出队列。
2. 实验分析(1)PCB结构通常包括以下信息：进程名，进程优先数，轮转时间片，进程已占用的CPU时间，进程还需要的CPU时间，进程的状态，当前队列指针等。
操作系统课程设计报告-进程调度算法模拟
1．课程设计的目的《操作系统原理》课程设计我们专业实践性环节之一，是学习完《操作系统原理》课程后进行的一次较全面的综合练习。
其目的在于加深对操作系统的理论、方法和基础知识的理解，掌握操作系统结构、实现机理和各种典型算法，系统地了解操作系统的设计和实现思路，培养学生的系统设计能力，并了解操作系统的发展动向和趋势。
2．课程设计的内容及要求先来先服务、短作业优先、时间片轮转、基于静态优先级的调度，基于高响应比优先的动态优先级调度算法实现，能够输出调度情况，并计算周转时间和平均周转时间。
要求使用链表，进程个数由用户提供，按照进程的实际个数生成PCB，程序能够让用户选择使用哪种调度算法，能够在Linux环境运行并验证结果。
程序要考虑用户界面的友好性和使用方便性。
进程基本信息可从文件读入，也可手动输入。
3、设计原理3.1先来先服务调度算法每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源创建进程，然后放入就绪队列3.2短作业优先调度算法短作业优先调度算法是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再重新调度。
3.3时间片轮转调度算法系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。
时间片的大小从几ms到几百ms。
当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。
3.4静态优先级调度算法把处理机分配给优先级最高的进程，使之执行。
但在其执行期间，只要出现了另一个比其优先级更高的进程，调度程序就将处理机分配给新到的优先级最高的进程。
这样就可以保证紧迫性作业优先运行。
3.5最高响应比优先的动态优先级调度算法优先权调度算法是为了照顾紧迫型作业，使之在进入系统后便获得优先处理，引入最高优先权优先调度算法。
操作系统进程调度模拟课程设计(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操作系统之上。
操作系统进程调度子系统的设计与实现——操作系统课程设计报告
本科学生课程设计任务书课程设计题目操作系统进程调度子系统的设计与实现学院计算机学院专业网络工程年级2008已知参数和设计要求：设计要求：通过编程实现操作系统进程调度子系统的基本功能，其中，必须实现的调度算法有：先来先服务、时间片轮转、多级反馈轮转法、优先级等，在程序设计过程中，要求要有良好清晰的界面来观测进程调度的执行过程，在每个调度算法展示时，可以看到所有有关的队列结构和其中的内容，如就绪队列、阻塞队列等结构的动态变化的过程。
需要的环境：主要开发平台基于windows平台。
使用Java、C、C++作为主要编码工具（其它开发工具也可选）。
学生应完成的工作：（1）完成课程设计的编码和测试。
（编码需要实现所提要求的基本功能）（2）上交课程设计报告（按照标准格式书写）课程设计的任务分配：黄进：实现时间片轮转，多级反馈轮转，程序的可视化，程序调试，写报告王博君：实现先来先服务，优先级算法(抢占式，非抢占式)，程序的调试和检查，写报告目前资料收集情况（含指定参考资料）：[1]计算机操作系统教程张尧学，史美林编著清华大学出版社2006第3版[2]Windows操作系统原理（重点大学计算机教材）尤晋元、史美林、陈向群等人编著清华大学出版社2001年8月第1版[3]计算机操作系统实验指导，郁红英，李春强，清华大学出版色，2008年9月第一版课程设计的工作计划：序号课程设计工作进度起止日期1 课程设计任务书下发2010.12.62 文献查阅和资料准备2010.12.6-2010.12.203 课程设计编码的设计2011.1.5-2011.1.64 编码测试和设计验收2011.1.7任务下达日期 2010年 12 月 6 日完成日期 2011年 1月 7 日指导教师（签名）学生（签名）正文目录摘要及关键词 (5)1 设计目的及内容 (6)2 设计方案 (6)3 程序功能模块设计 (6)4 程序总控流程图 (8)5 数据结构设计 (8)6 程序主要代码及解析.. .. .. .. .. .. .. .. .. .. .... .107 测试数据及测试结果 (14)7.1 主程序界面 (14)7.2 进程生成后界面 (15)7.3 开始模拟进程 (15)8设计过程中遇到的问题及解决方法 (17)9设计总结 (17)10 参考文献... .. (18)摘要现代计算机系统中，进程是资源分配和独立运行的基本单位，是操作系统的核心概念。
操作系统课程设计报告进程调度
前言操作系统（Operating System, 简称OS）是管理和控制计算机硬件与软件资源旳计算机程序, 是直接运营在“裸机”上旳最基本旳系统软件, 任何其他软件都必须在操作系统旳支持下才干运营。
操作系统是顾客和计算机旳接口, 同步也是计算机硬件和其他软件旳接口。
操作系统旳功能涉及管理计算机系统旳硬件、软件及数据资源, 控制程序运营, 改善人机界面, 为其他应用软件提供支持, 让计算机系统所有资源最大限度地发挥作用, 提供多种形式旳顾客界面, 使顾客有一种好旳工作环境, 为其他软件旳开发提供必要旳服务和相应旳接口等。
事实上, 顾客是不用接触操作系统旳, 操作系统管理着计算机硬件资源, 同步按照应用程序旳资源祈求, 分派资源, 如: 划分CPU时间, 内存空间旳开辟, 调用打印机等。
操作系统旳重要功能是资源管理, 程序控制和人机交互等。
计算机系统旳资源可分为设备资源和信息资源两大类。
设备资源指旳是构成计算机旳硬件设备, 如中央解决器, 主存储器, 磁盘存储器, 打印机, 磁带存储器, 显示屏, 键盘输入设备和鼠标等。
信息资源指旳是寄存于计算机内旳多种数据, 如系统软件和应用软件等。
操作系统位于底层硬件与顾客之间, 是两者沟通旳桥梁。
顾客可以通过操作系统旳顾客界面, 输入命令。
操作系统则对命令进行解释, 驱动硬件设备, 实现顾客规定。
本次课程设计我们将对上学期所学旳知识进行系统旳应用, 而达到巩固知识旳作用目录1问题概述 (2)2需求分析 (2)3 概要设计 (2)3.1重要功能 (2)3.2 模块功能构造 (3)3.3 软硬件环境 (3)3.4数据构造设计 (3)4 具体设计 (4)4.1“先来先服务（FCFS）调度算法” (4)4.2“短进程调度算法（SPF）” (7)4.3“高响应比优先调度算法” (10)4.4“优先级调度（非抢占式）算法” (13)5 系统测试及调试 (15)5.1测试 (15)5.2调试过程中遇到旳问题 (16)6 心得体会 (17)7 参照文献 (18)8 附录 (19)1问题概述编写一种进程调度程序, 容许多种进程并发执行。
模拟进程调度算法课程设计
模拟进程调度算法课程设计．课程概述1.1. 设计构想程序能够完成以下操作：创建进程：先输⼊进程的数⽬，再⼀次输⼊每个进程的进程名、运⾏总时间和优先级，先到达的先输⼊；进程调度：进程创建完成后就选择进程调度算法，并单步执⾏，每次执⾏的结果都从屏幕上输出来。
1.2. 需求分析在多道程序环境下，主存中有着多个进程，其数⽬往往多于处理机数⽬，要使这多个进程能够并发地执⾏，这就要求系统能按某种算法，动态地把处理机分配给就绪队列中的⼀个进程，使之执⾏。
分配处理机的任务是由处理机调度程序完成的。
由于处理机是最重要的计算机资源，提⾼处理机的利⽤率及改善系统必（吞吐量、响应时间），在很⼤程度上取决于处理机调度性能的好坏，因⽽，处理机调度便成为操作系统设计的中⼼问题之⼀。
本次实验在VC++6.0 环境下实现先来先服务调度算法，短作业优先调度算法，⾼优先权调度算法，时间⽚轮转调度算法和多级反馈队列调度算法。
1.3. 理论依据为了描述和管制进程的运⾏，系统为每个进程定义了⼀个数据结构——进程控制块PCB（Process Control Block）,PCB 中记录了操作系统所需的、⽤于描述进程的当前情况以及控制进程运⾏的全部信息，系统总是通过PCB 对进程进⾏控制，亦即，系统是根据进程的PCB ⽽不是任何别的什么⽽感知进程的存在的，PCB 是进程存在的惟⼀标志。
本次课程设计⽤结构体Process 代替PCB 的功能。
1.4. 课程任务⼀、⽤ C 语⾔（或C++ ）编程实现操作模拟操作系统进程调度⼦系统的基本功能；运⽤多种算法实现对进程的模拟调度。
⼆、通过编写程序实现进程或作业先来先服务、⾼优先权、按时间⽚轮转、短作业优先、多级反馈队列调度算法，使学⽣进⼀步掌握进程调度的概念和算法，加深对处理机分配的理解。
三、实现⽤户界⾯的开发1.5. 功能模块分析：1、进程概念：进程是被独⽴分配资源的最⼩单位。
进程是动态概念，必须程序运⾏才有进程的产⽣。
进程调度模拟程序课程设计
《操作系统》课程设计报告专业：计算机科学与技术班级：09计本班学号姓名成绩200981010118刘利刚题目名称：进程调度模拟程序完成日期：2012年6月20日甘肃政法学院计算机科学学院目录第一章课程设计目的 (3)第二章课程设计要求 (3)第三章设计思想 (5)3.1 基本概念 (5)3.2 进程控制块 (6)3.3 算法思想 (7)第四章详细设计 (8)4.1 程序设计流程图 (8)4.2 程序各模块功能介绍 (9)第五章运行结果及分析 (18)5.1 程序调试 (18)5.2 运行结果 (19)5.3 结果分析 (21)第六章总结 (22)参考文献 (22)进程调度模拟程序第一章课程设计目的深入掌握进程调度的概念原理和实现方法，理解操作系统进程管理中进行进程调度的过程和编程方法，掌握先来先服务调度算法和最高优先数优先的调度算法，创建进程控制块PCB。
理解进程的状态及变化，动态显示每个进程的当前状态及进程的调度情况。
进程调度是处理机管理的核心内容。
本次课程设计用C 语言编写模拟进程调度程序，以便加深理解有关进程控制快、进程队列等概念，并体会最高优先数优先与按时间片轮转调度结合算法的优缺点。
第二章课程设计要求编写一个进程调度程序，允许多个进程并行执行。
1、进程调度算法：采用最高优先数优先与按时间片轮转调度结合算法。
2、每个进程有一个进程控制块（PCB）表示。
进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
3、进程的优先数及需要的运行时间可在运行时输入，进程的到达时间为输入进程的时间。
4、进程的运行时间以时间片为单位进行计算。
5、每个进程的状态可以是就绪W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
6、就绪进程获得CPU后都只能运行一个时间片。
7、如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
操作系统课程设计-进程调度算法模拟
操作系统课程设计----进程调度算法模拟一、实验内容：模拟五种进程调度算法并计算各参数值二、实验原理：（1）先来先服务调度：最先到达的进程先进行调度（2）短作业优先调度：从已到达的进程中选出最短的进程优先调度（3）时间片轮转调度：每个进程依次的按时间片轮流的方式执行（4）静态优先权调度：赋予优先权，在已到达的进程中选出优先权最高的优先调度（5）高响应比优先调度：优先权随等待时间而增加，从而使等待时间较长且服务时间较短的进程优先调度响应比=1+等待时间/服务时间三、实验设计说明：本程序采用C++ Builder 5编程和设计界面考虑到调度算法较多，采用了多页面的界面（如下图），加入的进程限制五个，在文本框中模拟到达一进程后，输入到达时间和服务时间，点击“加入新进程”即可，输入完成之后，点击运行即可得到表中各值。
想从新输入可点击“清除”按钮。
关闭时直接点击“×”即可。
该程序还不是很完善，有一些小问题，尚待解决，还得向老师请教。
四、实验结果：（只打印两个结果示范）运行后操作面板初始化如下图：短作业优先结果如图：时间片轮转结果如图：（书上的例题）五、实验源程序：Unit1.h文件//---------------------------------------------------------------------------#ifndef Unit1H#define Unit1H//---------------------------------------------------------------------------#include <Classes.hpp>#include <Controls.hpp>#include <StdCtrls.hpp>#include <Forms.hpp>#include <ComCtrls.hpp>#include <Grids.hpp>#include <ExtCtrls.hpp>//--------------------------------------------------------------------------- class TForm1 : public TForm{__published: // IDE-managed ComponentsTPageControl *PageControl1; TTabSheet *TabSheet1; TTabSheet *TabSheet2; TTabSheet *TabSheet3; TTabSheet *TabSheet4; TabSheet *TabSheet5; TStringGrid *sgr;TButton *Button1;TButton *Button2;TButton *Button3; TStringGrid *sgr1;TButton *Button4;TButton *Button5;TButton *Button6; TStringGrid *sgr2;TButton *Button7;TButton *Button8;TButton *Button9; TStringGrid *sgr3;TButton *Button10; TButton *Button11; TButton *Button12; TStringGrid *sgr4;TButton *Button13; TButton *Button14; TButton *Button15;TLabel *Label1;TEdit *Edit1;TLabel *Label2;TEdit *Edit2;TEdit *Edit3;TEdit *Edit4;TLabel *Label3;TLabel *Label4;TEdit *Edit5;TLabel *Label5;TLabel *Label6;TEdit *Edit6; TLabel *Label7;TEdit *Edit7;TLabel *Label8;TLabel *Label9;TLabel *Label10;TEdit *Edit8;TEdit *Edit9;TEdit *Edit10;TLabel *Label11;TLabel *Label12;TEdit *Edit11;TEdit *Edit12;void __fastcall FormCreate(TObject *Sender);void __fastcall Button3Click(TObject *Sender);void __fastcall Button1Click(TObject *Sender);void __fastcall Button2Click(TObject *Sender);void __fastcall Button6Click(TObject *Sender);void __fastcall Button5Click(TObject *Sender);void __fastcall Button4Click(TObject *Sender);void __fastcall Button9Click(TObject *Sender);void __fastcall Button7Click(TObject *Sender);void __fastcall Button8Click(TObject *Sender);void __fastcall Button12Click(TObject *Sender); void __fastcall Button10Click(TObject *Sender); void __fastcall Button11Click(TObject *Sender);void __fastcall Button15Click(TObject *Sender); void __fastcall Button13Click(TObject *Sender); void __fastcall Button14Click(TObject *Sender);private: // User declarationspublic: // User declarations__fastcall TForm1(TComponent* Owner);};//---------------------------------------------------------------------------extern PACKAGE TForm1 *Form1;//---------------------------------------------------------------------------#endif******************************************************************************* Unit1.cpp文件//--------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop#include "Unit1.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;float super[6]; //优先权float come[6]; //到达时间float serve[6]; //服务时间float begin[6]; //开始执行时间float end[6]; //完成时间float all[6]; //周转时间float dall[6]; //带权周转时间float max(float,float,float);//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) //初始化表格: TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){sgr->Cells[0][0]="进程名";sgr1->Cells[0][0]="进程名";sgr2->Cells[0][0]="进程名";sgr3->Cells[0][0]="进程名";sgr4->Cells[0][0]="进程名";sgr3->Cells[0][1]="优先权";sgr->Cells[0][1]="到达时间";sgr1->Cells[0][1]="到达时间";sgr2->Cells[0][1]="到达时间";sgr3->Cells[0][2]="到达时间";sgr4->Cells[0][1]="到达时间";sgr->Cells[0][2]="服务时间";sgr1->Cells[0][2]="服务时间";sgr2->Cells[0][2]="服务时间";sgr3->Cells[0][3]="服务时间";sgr4->Cells[0][2]="服务时间";sgr->Cells[0][3]="开始执行时间";sgr1->Cells[0][3]="开始执行时间";sgr3->Cells[0][4]="开始执行时间";sgr4->Cells[0][3]="开始执行时间";sgr4->Cells[0][4]="等待时间";sgr4->Cells[0][5]="响应比";sgr->Cells[0][4]="完成时间";sgr1->Cells[0][4]="完成时间";sgr2->Cells[0][3]="完成时间";sgr3->Cells[0][5]="完成时间";sgr4->Cells[0][6]="完成时间";sgr->Cells[0][5]="周转时间";sgr1->Cells[0][5]="周转时间";sgr2->Cells[0][4]="周转时间";sgr3->Cells[0][6]="周转时间";sgr4->Cells[0][7]="周转时间";sgr->Cells[0][6]="带权周转时间";sgr1->Cells[0][6]="带权周转时间";sgr2->Cells[0][5]="带权周转时间";sgr3->Cells[0][7]="带权周转时间";sgr4->Cells[0][8]="带权周转时间";sgr->Cells[0][7]="显示调度结果";sgr1->Cells[0][7]="显示调度结果";sgr3->Cells[0][8]="显示调度结果";sgr4->Cells[0][9]="显示调度结果";}//---------------------------------------------------------------------------//先来先服务调度算法void __fastcall TForm1::Button3Click(TObject *Sender) //输入初值，5个{static int i=1;sgr->Cells[i][0]=i; //进程编号sgr->Cells[i][1]=Edit1->Text; //输入到达时间come[i]=StrToFloat(Edit1->Text); //赋到达时间给表格sgr->Cells[i][2]=Edit2->Text; //输入服务时间serve[i]=StrToFloat(Edit2->Text); // 赋服务时间给表格i++;if(i>5) i=1;}//---------------------------------------------------------------------------float max(float x,float y,float m) //定义函数{return (x+y)>m?(x+y):m;}//---------------------------------------------------------------------------//““运行”按键函数void __fastcall TForm1::Button1Click(TObject *Sender){int i=1;begin[1]=come[1];sgr->Cells[1][3]=begin[1]; //初始值for(i=2;i<=5;i++){begin[i]=max(serve[i-1],begin[i-1],come[i]); //调用函数sgr->Cells[i][3]=begin[i];} //开始执行时间for(i=1;i<=5;i++) //计算各个值{end[i]=begin[i]+serve[i];sgr->Cells[i][4]=end[i];all[i]=end[i]-come[i];sgr->Cells[i][5]=all[i];dall[i]=all[i]/serve[i];sgr->Cells[i][6]=dall[i];sgr->Cells[i][7]=i;}}//---------------------------------------------------------------------------//“清除”按键函数void __fastcall TForm1::Button2Click(TObject *Sender){ int i=0,j=0;for(i=0;i<=7;i++)for(j=1;j<=5;j++){sgr->Cells[j][i]="";}}//---------------------------------------------------------------------------//短作业优先调度函数//“加入新进程”输入初值void __fastcall TForm1::Button6Click(TObject *Sender){static int i=1;sgr1->Cells[i][0]=i; //进程编号sgr1->Cells[i][1]=Edit3->Text;come[i]=StrToFloat(Edit3->Text);sgr1->Cells[i][2]=Edit4->Text;serve[i]=StrToFloat(Edit4->Text);i++;if(i>5) i=1;}//---------------------------------------------------------------------------//“清除”按键函数void __fastcall TForm1::Button5Click(TObject *Sender){ int i=0,j=0;for(i=0;i<=7;i++)for(j=1;j<=5;j++){sgr1->Cells[j][i]="";}}//---------------------------------------------------------------------------//“运行”按钮函数void __fastcall TForm1::Button4Click(TObject *Sender){int i,j,k,run=1,index=1,flag[6]={1,1,1,1,1,1},t[4]; //flag用于设置访问值“1”为未访问sgr1->Cells[1][7]="1";begin[1]=come[1];sgr1->Cells[1][3]=FloatToStr(begin[1]);end[1]=begin[1]+serve[1];sgr1->Cells[1][4]=FloatToStr(end[1]);sgr1->Cells[1][5]=FloatToStr(end[1]-come[1]);sgr1->Cells[1][6]=FloatToStr((end[1]-come[1])/serve[1]); //初始化for(j=1;j<=4;j++){index++; //index自动指向下一个进程if (index>5) //index值的复位{for(k=2;k<=5;k++)if (flag[k]==1){index=k; //index指向第一个未执行的进程break;}}for(i=2;i<=5;i++)//满足三个条件的进程才可调度，1、已到达2、未调度过3、服务时间最小{ if ((come[i]<=end[run])&&(serve[index]>serve[i])&&(flag[i]==1)){index=i;}else if (come[i]>end[run]) //如果一进程完成未有进程到达，则下一个进程到来就直接调度break;}flag[index]=0;//处理index，index为当前运行的进程编号，run为上一个进程的编号begin[index]=max(serve[run],begin[run],come[index]); //开始执行时间sgr1->Cells[index][3]=FloatToStr(begin[index]);run=index;end[index]=begin[index]+serve[index]; //计算完成时间sgr1->Cells[index][4]=FloatToStr(end[index]);all[index]=end[index]-come[index]; //计算周转时间sgr1->Cells[index][5]=FloatToStr(all[index]);sgr1->Cells[index][6]=FloatToStr(all[index]/serve[index]); //赋带权周转时间t[j]=index; // t[j]为调度序列}for(i=1;i<=4;i++)sgr1->Cells[i+1][7]=FloatToStr(t[i]); //显示调度结果}//---------------------------------------------------------------------------//时间片轮转调度算法void __fastcall TForm1::Button9Click(TObject *Sender){static int i=1;sgr2->Cells[i][0]=i; //进程编号sgr2->Cells[i][1]=Edit5->Text;come[i]=StrToFloat(Edit5->Text);sgr2->Cells[i][2]=Edit6->Text;serve[i]=StrToFloat(Edit6->Text);i++;if(i>5) i=1;}//---------------------------------------------------------------------------//“运行”按钮函数void __fastcall TForm1::Button7Click(TObject *Sender){int i=1,j=1,flag[6]={1,1,1,1,1,1};float t=0,q,a[6]; // q为时间片大小q=StrToFloat(Edit7->Text); //赋值给qfor(i=1;i<=5;i++)a[i]=serve[i];for(j=1;j<=100;j++) //设总时间片不超过100{for(i=1;i<=5;i++){if(flag[i]==1){ serve[i]-=q; //计算服务时间if(serve[i]>0){t+=q; //t为当前执行的总时间}else if(serve[i]<=0){t+=(q+serve[i]); //t为当前执行的总时间end[i]=t; //进程调度完毕送完成时间flag[i]=0; //一旦进程被调度后置flag值为0}}}}for(i=1;i<=5;i++) //显示结果{sgr2->Cells[i][3]=FloatToStr(end[i]);all[i]=end[i]-come[i];sgr2->Cells[i][4]=FloatToStr(all[i]);sgr2->Cells[i][5]=FloatToStr(all[i]/a[i]);}}//---------------------------------------------------------------------------//“清除”按键函数void __fastcall TForm1::Button8Click(TObject *Sender){int i=0,j=0;for(i=0;i<=6;i++)for(j=1;j<=5;j++){sgr2->Cells[j][i]="";}}//---------------------------------------------------------------------------//优先权调度算法（原理类似短作业优先）//“加入新进程”输入初值void __fastcall TForm1::Button12Click(TObject *Sender){static int i=1;sgr3->Cells[i][0]=i; //进程编号sgr3->Cells[i][1]=Edit8->Text;super[i]=StrToFloat(Edit8->Text);sgr3->Cells[i][2]=Edit9->Text;come[i]=StrToFloat(Edit9->Text);sgr3->Cells[i][3]=Edit10->Text;serve[i]=StrToFloat(Edit10->Text);i++;if(i>5) i=1;}//---------------------------------------------------------------------------//“运行”按钮函数void __fastcall TForm1::Button10Click(TObject *Sender){int i,j,k,run=1,index=1,flag[6]={1,1,1,1,1,1},t[4]; //run为上一个调度的进程号sgr3->Cells[1][8]="1";begin[1]=come[1];sgr3->Cells[1][4]=FloatToStr(begin[1]);end[1]=begin[1]+serve[1];sgr3->Cells[1][5]=FloatToStr(end[1]);sgr3->Cells[1][6]=FloatToStr(end[1]-come[1]);sgr3->Cells[1][7]=FloatToStr((end[1]-come[1])/serve[1]);//初始化for(j=1;j<=4;j++){index++;while(flag[index]==0){index++;} //index指向下一个待运行的进程if (index>5) //index值的复位{for(k=2;k<=5;k++)if (flag[k]==1){index=k;break;}}for(i=2;i<=5;i++){ if ((come[i]<=end[run])&&(super[index]>super[i])&&(flag[i]==1)){index=i; //满足条件的进程号送给index}else if (come[i]>end[run])break;}flag[index]=0;//处理indexbegin[index]=max(serve[run],begin[run],come[index]);sgr3->Cells[index][4]=FloatToStr(begin[index]);run=index;end[index]=begin[index]+serve[index];sgr3->Cells[index][5]=FloatToStr(end[index]);all[index]=end[index]-come[index];sgr3->Cells[index][7]=FloatToStr(all[index]/serve[index]);t[j]=index;}for(i=1;i<=4;i++)sgr3->Cells[i+1][8]=FloatToStr(t[i]);}//---------------------------------------------------------------------------//“清除”按键函数void __fastcall TForm1::Button11Click(TObject *Sender){int i=0,j=0;for(i=0;i<=9;i++)for(j=1;j<=5;j++)sgr3->Cells[j][i]="";}//---------------------------------------------------------------------------//高响应比优先调度算法（类似优先权调度算法，响应比为动态的）//“清除”按键函数void __fastcall TForm1::Button15Click(TObject *Sender){static int i=1;sgr4->Cells[i][0]=i; //进程编号sgr4->Cells[i][1]=Edit11->Text;come[i]=StrToFloat(Edit11->Text);sgr4->Cells[i][2]=Edit12->Text;serve[i]=StrToFloat(Edit12->Text);i++;if(i>5) i=1;}//---------------------------------------------------------------------------//“运行”按钮函数void __fastcall TForm1::Button13Click(TObject *Sender){int i,j,k,run=1,index=1,flag[6]={1,1,1,1,1,1},t[4];float xy[6]; //xy[]为响应比数组sgr4->Cells[1][9]="1";begin[1]=come[1];sgr4->Cells[1][3]=FloatToStr(begin[1]);sgr4->Cells[1][4]="0";xy[1]=1+0;sgr4->Cells[1][5]=FloatToStr(xy[1]);end[1]=begin[1]+serve[1];sgr4->Cells[1][6]=FloatToStr(end[1]);sgr4->Cells[1][8]=FloatToStr((end[1]-come[1])/serve[1]); //初始化for(j=1;j<=4;j++){index++;if (index>5){for(k=2;k<=5;k++)if (flag[k]==1){index=k;break;}}for(i=2;i<=5;i++){ if ((come[i]<end[run])&&((end[run]-come[index])/serve[index]<(end[run]-come[index])/serve[i]) &&(flag[i]==1)) //动态计算响应比并比较{index=i;}else if (come[i]>end[run])break;}flag[index]=0;//处理indexbegin[index]=max(serve[run],begin[run],come[index]);sgr4->Cells[index][3]=FloatToStr(begin[index]);sgr4->Cells[index][4]=FloatToStr(end[run]-come[index]);xy[index]=1+(end[run]-come[index])/serve[index];sgr4->Cells[index][5]=FloatToStr(xy[index]);run=index;end[index]=begin[index]+serve[index];sgr4->Cells[index][6]=FloatToStr(end[index]);all[index]=end[index]-come[index];sgr4->Cells[index][7]=FloatToStr(all[index]);sgr4->Cells[index][8]=FloatToStr(all[index]/serve[index]);t[j]=index;}for(i=1;i<=4;i++)sgr4->Cells[i+1][9]=FloatToStr(t[i]);}//---------------------------------------------------------------------------//“清除”按键函数void __fastcall TForm1::Button14Click(TObject *Sender){int i=0,j=0;for(i=0;i<=9;i++)for(j=1;j<=5;j++)sgr4->Cells[j][i]="";}//---------------------------------------------------------------------------六、实验总结：此次实验花了一周多的时间完成了程序的编写和界面设计，这其中也走了不少弯路。
操作系统课程设计报告模拟进程调度程序(一)
操作系统课程设计报告模拟进程调度程序(一) 此设计报告是对操作系统中进程调度的两种算法，即静态优先权调度算法和需要时间片的转法进行了描述，并分析了它们的工作机理。
最高优先权调度算法的基本思想是把CPU分配给就绪队列中优先权最高的进程。
静态优先数是在创建进程时确定的，并在整个进程运行期间不再改变。
简单轮转法的基本思想是：所有就绪进程按FCFS排成一个队列，总是把处理机分配给队首的进程，各进程占用CPU的时间片相同。
如果运行进程用完它的时间片后还未完成，就把它送回到就绪队列的末尾，把处理机重新分配给队首的进程，直至所有的进程运行完毕。
然后用具体语言模拟了一个进程调度的程序。
用户可以自己输入产生进程，然后选择调度方式进行调度。
所用的语言为，结果显示了调度运行过程。
问题描述和分析………………………………………………4算法设计............................................................5源代码及说明.........................................................5结果与分析...............................................................17参考文献 (18)一、问题描述和分析问题描述CPU调度是多道程序操作系统的基础，几乎所有计算机资源在使用前都要被调度，因此，CPU调度对于操作系统来说非常重要。
假如操作系统中存在若干进程，这些进程，将会被按照指定的调度方式，由CPU进行调度。
本程序，用来模拟实现操作系统中的两种调度方法，即：优先权调度和轮转法调度。
下面对四种调度方法进行描述优先权调度（priority-schedulingalgorithm）：在这种方式下，每一个进程都有一个优先权与其关联，具有最高优先权的进程会被分配到CPU，具有相同优先权的进程按FCFS顺序调度。
操作系统课程设计进程调度模拟源代码
runqueue->next=NULL;//从就绪队列选一个节点，插入运行队列
runqueue->killtime=timeslice;//计算消耗的时间
runqueue->runedtime=runqueue->runedtime+runqueue->killtime;//计算总共运行时间
return 0;
}
printf("kill name %d, runtime=%d, runedtime=%d,killtime=%d\n"
,runqueue->name,runqueue->runtime,runqueue->runedtime,runqueue->killtime);
n++;
delete(runqueue);
,runqueue->name,runqueue->runtime,runqueue->runedtime,runqueue->killtime);
}
else if(runqueue->runtime<=0){//判断是否结束
runqueue->killtime=0;
runqueue->runtime=0;
else if(top_wait->next!=NULL){//
p=top_wait;
while(p->next!=temp){
p=p->next;
}
if(temp==tail_wait)
tail_wait=p;
p->next=temp->next;
操作系统课程设计——进程调度模拟算法(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先到先服务算法描述：把所有进程按到达先后排序，每次取最先到的进程执行后淘汰，再取下一个，直到所有进程调度完毕。
(完整word版)进程调度模拟程序设计
进程调度模拟程序设计一、实验目的按优先数调度算法或时间片轮转法模拟处理器调度,从而进一步理解处理器调度的原理。
二、实验内容1.设计思路（1）数据结构定义（a)对于不同的调度算法，定义不同的PCB结构体typedef struct PCB_type1 {char name［10］; //进程名char state；//进程状态R—-就绪状态E——结束状态int need_time; //运行需要的CPU时间(需运行的时间片个数）int priority;｝PCB_P; //按优先数调度算法的PCB结构体typedef struct PCB_type2 ｛char name［10]；//进程名int state; //进程状态R-—就绪状态E——结束状态int need_time; //运行需要的CPU时间（需运行的时间片个数）int used_time; //}PCB_T；//按时间片轮转算法的PCB结构体(b）用全局变量choice来指明当前应用的调度算法int choice；(c)为了模拟调度,可以利用STL定义队列deque<PCB_P> q1;queue〈PCB_T〉q2；(2）程序主要模块一共有三个自定义函数,分别是：start_state（) 提示用户选择调度算法，初始化进程信息。
dispatch(）模拟调度(a)对于优先数调度算法，每次调度前对队列里的进程按优先数从大到小排序,然后调度选中队首的进程，将其出队列，并将进程优先数和需要运行时间减1。
如果此进程的需要运行时间不为0，则继续将此进程入队；如果此进程的需要运行时间为0了,则将其状态置为结束状态。
重复上述过程直至队列为空.(b)对于时间片轮转算法，调度选中队首的进程，将其出队列,并将进程已用时间加1。
如果此进程要求运行时间已运行时间，则尚未执行结束，继续将此进程入队；如果此进程的要求运行时间=已运行时间，则已经执行结束，将其状态置为结束状态。
操作系统课程设计-进程调度的模拟实现
课程设计题目进程调度算法模拟编程学生姓名学号专业计算机科学与技术班级指导教师完成日期2０1２年12月18日进程调度的模拟实现摘要：进程管理是操作系统中的重要功能,用来创建进程、撤消进程、实现进程状态转换，它提供了在可运行的进程之间复用CPU的方法。
在进程管理中,进程调度是核心，因为在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态,当就绪进程个数大于处理器数目时，就必须依照某种策略决定哪些进程优先占用处理器。
本文通过两种算法模拟实现了进程之间的调度。
关键词:进程创建，先来先服务,优先级调度。
一．前言在操作系统中，调度的实质是一种资源分配，调度算法即指：根据系统的资源分配策略所规定的资源分配算法。
对于不同的系统和系统目标,通常采用不同的调度算法,如在批处理系统中，为照顾为数众多的短作业,采用短作业有限调度算法；在分时系统中,为保证系统具有合理的响应时间,采用轮转法进行调度。
采用算法时，则要考虑多方面因素，以便达到最佳效果。
做好这个课程设计,有利于加深对操作系统进程调度知识的理解。
二. 系统总体框架设计本程序采用两种算法（最高优先级数优先的调度算法和先来先服务算法）对多个进程进行调度，每个进程有三个状态，初始状态为就绪状态。
最高优先级数优先的调度算法中,程序的某进程运行时间以时间片为单位计算。
各进程的优先数或轮转时间数以及进程需运行的时间片数的初始值均由用户给定。
在优先级数优先的调度算法中,优先级数的值设计为100与运行时间的差值,即Pro_ｔime-pｒoceｓｓ->nｅedtｉme。
进程每执行一次,优先数减3,ＣＰＵ时间片数加1，进程还需要的时间片数减1。
对于遇到优先数一致的情况,采用先来先服务策略解决。
程序设计组成框图程序流程图1．可强占优先调度算法实现过程流程图：开始创建进程及属性先来先服务算法优先数调度算法显示进程执行状态结束2先来先服务调度算法实现过程流图三．数据结构设计1．设计创建进程的结构类型定义和结构变量说明sｔrｕｃt PrｏcessPｃb,定义PCＢ相关变量:PｒoｃeｓｓＰcb(){nｅxt=ＮULL;}chaｒｐｒo_naｍe[20]; ／／进程的名字ﻩint ｔime_sｕbmit ; //提交时间,从时间为1开始计时inｔｔｉme_ｅｘe ; //进程所需的运行时间ﻩinｔpro_ｉd ；/／进程ID(系统生成）ﻩint prｏ＿ｐriｏriｔｙ ; ／/进程优先级ﻩinｔ tiｍe＿starｔ ; //开始执行的时间ﻩint tiｍe＿end ; //结束的时间ﻩint ｔimｅ_ｗaiｔ ; ／/等待的时间ﻩint pｒo_ｓtａtｅ； //进程的状态(就绪,执行，完成) int time_lｅft ; /／还需多少时间单位,初始化为所需的执行时间ｉnｔ time_ｔuｒｎ；ﻩ //周转时间ﻩdｏｕble time_ａver ； //带权周转时间2.创建PCB类ｃlass CｐuＭodel,定义程序中使用的各函数:ＣｐuMｏｄeｌ{ＣｐuＭｏdel(）{pcbnｕm=0；}ｖoiｄｃpｕrｕn(); //cpu模拟运行函数ﻩbool ＧｅtPｃb（); /／进程输入函数ﻩvoiｄ ShowＰcb(); //将输入的进程展示出来voiｄＰriＭodeｌ(）； //可强占的优先进程调度模式void ＦｃfsMｏdel(); //先到先服务调度模式ProcｅssPcb ＰcbLiｓt[100］;ﻩ/／按提交时间排的未就绪进程队列()｝四．测试结果及分析1.开始运行，显示：２.输入进程数，各进程属性:关于提交时间执行时间等,将检测输入是否数字，不是数字即退出程序。
操作系统进程调度模拟算法附源码
先来先服务（FCFS）
定义：按照进程到 达的先后顺序进行 调度
优点：实现简单， 适用于CPU繁忙型 进程
缺点：等待时间较 长，可能导致饥饿 现象
适用场景：适用于 CPU密集型进程， 不适用于I/O密集 型进程
最短作业优先（SJF）
定义：按照作业的估计运行时间进行排序，选择最短作业优先执行 优点：响应时间快，作业平均等待时间少 缺点：存在饥饿现象，长作业可能长时间得不到执行 适用场景：适用于作业量较大且作业到达时间间隔较长的情况
Part Five
模拟实验结果及分 析
实验环境及参数设置
处理器：Intel Core i78700K
操作系统：Linux
内存：16GB DDR4 硬盘：256GB SSD
实验结果展示
实验数据：模拟算法在不同情况下的运行结果 数据分析：对实验数据进行分析，得出结论 结果对比：将模拟算法与实际操作系统进行对比，分析差异 结果展示：以图表、表格等形式展示实验结果
优先级调度算法
定义：根据进 程的优先级进 行调度，优先 级高的进程优 先获得处理器
资源
分类：静态优 先级调度算法 和动态优先级
调度算法
静态优先级调 度算法：优先 级在进程创建 时就确定，且 在运行过程中
保持不变
动态优先级调 度算法：优先 级根据进程的 行为和需求动
态调整
轮转法（RR）
定义：轮转法是 一种简单且常用 的进程调度算法， 也称为循环调度
算法。
原理：按照进程 到达的先后顺序， 按照固定的时间 片进行循环调度。
特点：每个进程 分配一个固定时 间片，时间片用 完后自动切换到 下一个进程，如 果时间片未用完， 则一直运行直到
模拟进程调度功能的设计与实现操作系统课程设计(JAVA版本)
模拟进程调度功能的设计与实现操作系统课程设计(J A V A版本)本页仅作为文档页封面，使用时可以删除This document is for reference only-rar21year.March操作系统课程设计--进程调度子系统模拟实现一、设计内容及意义1.课程设计内容使用java语言或C++语言编程实现模拟操作系统进程调度子系统的基本功能；实现先来先服务、时间片轮转、多级反馈轮转法对进程进行的调度过程；掌握各个调度算法的特点。
2.该课程设计意义理解进程调度的概念深入了解进程控制块的功能、进程的创建、删除以及进程各个状态间的转换过程从实用的角度对《数据结构》课程内容进行更深入理解和更熟练的应用进一步练习对Java及C++语言的熟练使用二、设计方案1.硬件环境PC一台2.开发语言及工具操作系统：MS windows XPC++版：Visual Studio 2008 + MFCJava版：Eclipse + Java Swing3.设计思路系统设备表用于存取调度过程中进程可申请的资源进程控制块主要负责具体进程信息的保存等待队列、就绪队列、完成队列用于保存执行过程的状态信息进程调度进程（类、线程）在就绪队列与等待队列之间进行调度主界面显示调度过程的三个队列的状态信息用户创建进程放入就绪队列等待调度三、功能模块设计1.进程状态转换等待就绪执行创建进程进程结束2.PCB信息主要负责保存各进程基本信息提供外部状态设置和读取接口3.系统设备类系统设备的基本信息设备状态设置、读取接口4.调度类向就绪队列添加新创建进程从就绪队列取相应进程执行将执行阻塞进程放入等待队列检测系统设备表，分配、释放设备、唤醒等待进程执行完成程序放入完成队列（仅为保存状态，非系统部分）提供获取执行状态的外部接口，即各个队列数据的获取5.视图类提供用户操作接口（调度策略选择、进程创建）显示各队列状态信息创建进程调度类线程，调用调度类的接口四、程序总控流程图1.用户接口、调度算法、进程状态转换关系示意系统总体设计页面 12.调度算法基本工作流程示意用户选择进程调度算法创建进程根据算法从就绪队列调度某一时刻需要资源从就绪队列取出执行放入等待队列Y执行完毕资源满足YY就绪队列是否有进程等待执行N初始化进程基本信息将进程放入就绪队列页面 1进程调度框架五、 数据结构设计1. PCB （进程基本信息）类结构ProcessPCB--------Pid Pname userName Priotity subtime totalTime runTimeDcRequestLst: int : String : String : int : int : int : int: List<DeviceReq>说明1. pid 进程ID2.pName进程名erName进程用户4.priority进程优先级5.subtime进程提交时间6.totalTime进程需要执行的总时间7.runtime进程已经运行时间8.dcReqlst当前进程所需要的设备请求表2.Dispatcher（进程调度进程）类结构Dispatcher-------SystimeisContentionpreLstwaitLstfinishLstexecutingsysDcLst: int: boolean: List<Process>: List<Process>: List<Process>: Process: List<Process>说明1.sysTime系统时间2.isContention当前调度是否为抢占方式3.prelst就绪队列4.waitlst等待队列5.finishlst完成队列6.executing正在执行的进程7.sysDclst系统设备表3.Device（系统设备）类结构Device------dcIddcTypedcDiscdcTimedcPiddcleftTime: int: int: String: int: int: int说明1. dcid 设备标识2. dcType 设备类型3. dcTime 该设备一次I/O 服务需要时间4. dcPid 使用该设备的进程5. dcDisc 设备描述6. dcLefTime 设备剩余服务时间六、 程序代码结构1. 类层次关系0..10..*0..10..*0..10..*DispatcherFIFODispatcherPLevelDispatcherRRDispatcherMRDispatcherProcessPCBDeviceDeviceReq2. 详细说明Dispatcher 定义进程调度进程的基本信息和接口FIFODispatcher 、PLevelDispatcher 、RRDispatcher 、MRDispatcher 分别实现相应的调度算法 Device 为系统设备DeviceReq 为进程设备请求，包括请求设备ID 和时间七、 代码实现分析1. 算法分析（各算法过程见下流程图）设备的分配释放先来先服务优先级调度时间片轮转多级反馈轮转设备分配释放页面 1先进先出进程调度算法页面 1优先级进程调度算法（抢占式）页面 1时间片轮转调度算法页面 1多级反馈轮转调度算法（抢占式）页面 12.具体实现（代码部分有详细注释）进程的插入@Overridepublic void addPreProc(Process proc) { 3.算机操作系统教程第2版.清华大学出版社2000年4.著作：[2] 张尧学.计算机操作系统教程第2版习题与实验指导. 清华大学出版21。
模拟进程调度功能的设计与实现操作系统课程设计(含源文件)
目录1、设计目的意义 (2)1.1、目的意义 (2)1.2、实现目标 (2)2、设计方案 (3)2.1、软硬件环境 (3)2.2、开发工具 (3)2.3、思路 (3)3、程序功能模块设计 (4)3.1、总体模块 (4)3.2、部分模块 (4)3.3、详细功能描述 (6)4、程序总控流程图 (6)5、数据结构设计 (8)5.1、PCB结构 (8)5.2、进程状态结构 (8)5.3、控件结构 (9)6、程序代码结构 (9)7、程序主要代码解析 (10)8、测试数据及测试结果 (15)8.1、运行时部分界面 (15)8.2、数据测试记录 (17)9、设计过程中遇到的问题及解决方法……………………………………………………………1810、结论 (18)10.1、系统实现情况 (18)10.2、系统特点 (18)10.3、设计体会及收获 (18)11、参考资料 (19)模拟进程调度功能的设计与实现1、设计目的意义1.1、目的意义●通过课程设计理解进程调度的概念，深入了解进程控制的功能、进程的创建、删除以及进程各个状态间的转换过程；实现先来先服务、时间片轮转、最短作业优先、优先级调度算法对进程进行的调度过程；通过观察有关的队列结构的内容的动态变化过程深入体会各个调度算法的特点；从而能够更好的巩固从书本上学到的知识。
●编程过程中需要建立队列等结构进行各种操作，通过该次课程设计，我们更加从实用的角度对《数据结构》课程内容进行更深入理解和更熟练的应用。
●使用C++语言进行编程，通过对调度功能的编程实现，不但能有效训练我们对编程语言的熟练使用，还能促进我们独立思考解决问题、以及独立查新获取知识的能力。
1.2、实现目标初始态、执行状态、状态。
通过系统设计，实现进程相关数据结构的创建和查看功能；实现多种进程调度算法：先来先服务算法、优先级调度算法、时间片轮转法等；实现对执行进程的阻塞，对等待进程的唤醒等功能。
进程的转换过程如下2、设计方案2．1 软硬件环境●硬件设备： PC机●软件设备：WINDOWSXP、Microsoft Visual C++ 6.02．2、开发工具●由于现在使用的操作系统大多数都是微软公司的产品，为了更好更贴近的模拟操作系统中进程调度功能，我们选择使用C++语言，开发平台Microsoft Visual C++ 6.0，借助MFC来完成应用Windows应用程序的开发。
操作系统课程设计报告进程调度
前言操作系统（OperatingSystem，简称OS）是管理和控制计算机硬件与软件资源的计算机程序，是直接运行在“裸机”上的最基本的系统软件，任何其他软件都必须在操作系统的支持下才能运行。
操作系统是用户和计算机的接口，同时也是计算机硬件和其他软件的接口。
操作系统的功能包括管理计算机系统的硬件、软件及数据资源，控制程序运行，改善人机界面，为其它应用软件提供支持，让计算机系统所有资源最大限度地发挥作用，提供各种形式的用户界面，使用户有一个好的工作环境，为其它软件的开发提供必要的服务和相应的接口等。
实际上，用户是不用接触操作系统的，操作系统管理着计算机硬件资源，同时按照应用程序的资源请求，分配资源，如：划分CPU时间，内存空间的开辟，调用打印机等。
操作系统的主要功能是资源管理，和等。
计算机系统的资源可分为设备资源和信息资源两大类。
设备资源指的是组成计算机的硬件设备，如，主存储器，，打印机，磁带存储器，显示器，键盘输入设备和鼠标等。
信息资源指的是存放于计算机内的各种数据，如系统软件和应用软件等。
操作系统位于底层硬件与用户之间，是两者沟通的桥梁。
用户可以通过操作系统的用户界面，输入命令。
操作系统则对命令进行解释，驱动硬件设备，实现用户要求。
本次课程设计我们将对上学期所学的知识进行系统的应用，而达到巩固知识的作用目录1问题概述编写一个进程调度程序，允许多个进程并发执行。
采取多种进程调度算法（先来先服务（FCFS）调度算法，短进程调度算法（SPF），高响应比优先调度算法，优先级调度（非抢占式）算法）。
分析比较各个算法的优缺点。
2需求分析进程调度的功能是记录系统中所有进程的执行情况、从就绪态队列中选择一个进程，进行进程上下文的切换。
采取不同的算法根据外部环境及条件进行进程的切换。
3概要设计主要功能进程调度的功能是记录系统中所有进程的执行情况、从就绪态队列中选择一个进程，进行进程上下文的切换。
采用先来先服务（FCFS）调度算法，短进程调度算法（SPF），高响应比优先调度算法，优先级调度（非抢占式）算法进行进程的切换。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
目录1、设计目的意义 (2)1.1、目的意义 (2)1.2、实现目标 (2)2、设计方案 (3)2.1、软硬件环境 (3)2.2、开发工具 (3)2.3、思路 (3)3、程序功能模块设计 (4)3.1、总体模块 (4)3.2、部分模块 (4)3.3、详细功能描述 (6)4、程序总控流程图 (6)5、数据结构设计 (8)5.1、PCB结构 (8)5.2、进程状态结构 (8)5.3、控件结构 (9)6、程序代码结构 (9)7、程序主要代码解析 (10)8、测试数据及测试结果 (15)8.1、运行时部分界面 (15)8.2、数据测试记录 (17)9、设计过程中遇到的问题及解决方法……………………………………………………………1810、结论 (18)10.1、系统实现情况 (18)10.2、系统特点 (18)10.3、设计体会及收获 (18)11、参考资料 (19)模拟进程调度功能的设计与实现1、设计目的意义1.1、目的意义●通过课程设计理解进程调度的概念，深入了解进程控制的功能、进程的创建、删除以及进程各个状态间的转换过程；实现先来先服务、时间片轮转、最短作业优先、优先级调度算法对进程进行的调度过程；通过观察有关的队列结构的内容的动态变化过程深入体会各个调度算法的特点；从而能够更好的巩固从书本上学到的知识。
●编程过程中需要建立队列等结构进行各种操作，通过该次课程设计，我们更加从实用的角度对《数据结构》课程内容进行更深入理解和更熟练的应用。
●使用C++语言进行编程，通过对调度功能的编程实现，不但能有效训练我们对编程语言的熟练使用，还能促进我们独立思考解决问题、以及独立查新获取知识的能力。
1.2、实现目标初始态、执行状态、状态。
通过系统设计，实现进程相关数据结构的创建和查看功能；实现多种进程调度算法：先来先服务算法、优先级调度算法、时间片轮转法等；实现对执行进程的阻塞，对等待进程的唤醒等功能。
进程的转换过程如下2、设计方案2．1 软硬件环境●硬件设备： PC机●软件设备：WINDOWSXP、Microsoft Visual C++ 6.02．2、开发工具●由于现在使用的操作系统大多数都是微软公司的产品，为了更好更贴近的模拟操作系统中进程调度功能，我们选择使用C++语言，开发平台Microsoft Visual C++ 6.0，借助MFC来完成应用Windows应用程序的开发。
另外通过课余时间的学习，对Windows 应用程序的开发过程也有一些了解，很想学以致用，做点使用的东西加深对学习过的知识的理解与吸收。
2.3、思路进程根据外界条件的不断变化引起状态的改变，可以利用系统时间片的大小、进程执行时间、进入主存的时间、系统内存大小、以及调度算法的选择来作为条件对进程进行调度。
通过在对话框中添加按钮、文本编辑框、列表等控件，并为控件关联相应的变量和消息函数，实现各个控件内部以及控件之间的协同工作，并使用定时器进行时间的设置，从而完成系统所要求的进程调度工作。
Windows应用程序，操作系统，计算机硬件之间的相互关系如下：3、程序功能模块设计（程序功能模块划分及层次等）3.1、总体模块应用程序消息队列操作系统输入输出设备3.2、部分模块3.3、详细功能描述根据需要设置系统内存的大小●选择不同的进度调度算法进行进程调度模拟●设置进程的各种属性值创建进程●根据进程不同的状态放在不同的位置显示进程调度过程中的动态变化情况●在某一时间点击按钮进行进程调度模拟●进程调度模拟过程中可以暂停调度过程，查看进程的状态变化过程●通过双击状态列表中的某个进程可以查看进程的各属性值●对执行进程、就绪进程进行强制“阻塞”操作●对等待进程进行强制“就绪”操作●将没有执行完毕的进程进行强制“杀死”操作4、程序总控流程图(见下页)5、数据结构设计5.1、PCB结构开始设置内存大小新添加的进程所需要的资源因为主存的限制按先后顺序进入就绪队列或是等待队列选择不同的调度算法创建新的进程开始调度按不同的调度算法开始进行对处于不同状态队列的进程进行阻塞、就绪、杀死等操作暂停操作可以停止进程调度并可以继续执行双击某个进程可以查看进程的属性、复位操作清空各状态队列等只要各进程状态队列不空，根据不同的条件，进程状态而改执行进程执行条件不满足则立即进入等待队列或是就绪队列一旦有执行进程执行完毕或是转为别的状态，就从就绪队列选择一个执行只要剩余内存允许，就从等待队列中选择进程进入就绪队列直至各队列全为结束本图只是系统运行时的大致过程5.2、进程状态结构5.3、控件结构6、程序代码结构●程序主要函数如下，各函数通过关联相关变量进行消息传递●CProgressExDlg::CProgressExDlg(CWnd* pParent /*=NULL*/): CDialog(CProgressExDlg::IDD, pParent)构造函数，调用基类CProgressExDlg，并传递两个参数：一个CProgressExDlg类的IDD成员，一个是父窗口指针。
●void CProgressExDlg::DoDataExchange(CDataExchange* pDX)主要用来完成对话框数据的交换和校验。
●void CProgressExDlg::OnButPause()用于暂停进程调度操作●void CProgressExDlg::OnButStart()用于启动进程调度●void CProgressExDlg::OnButton1()用于复位，清除各进程●void CProgressExDlg::OnButton2()用于创建进程●void CProgressExDlg::OnButtonBlock()用于使选定进程进入就绪状态●void CProgressExDlg::OnButtonKill()用于杀死选定进程●void CProgressExDlg::OnButtonNotify()用于阻塞选定进程●HBRUSH CProgressExDlg::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)用于设置显示进程属性时的字体和颜色●void CProgressExDlg::OnDblclkListReadypro()用于双击就绪队列中的某个进程，进而显示其属性●void CProgressExDlg::OnDblclkListRunpro()用于双击执行队列中的某个进程，进而显示其属性●void CProgressExDlg::OnDblclkListWaitpro()用于双击等待队列中的某个进程，进而显示其属性●BOOL CProgressExDlg::OnInitDialog()初始化对话框●void CProgressExDlg::OnPaint()绘制对话框●void CProgressExDlg::OnTimer(UINT nIDEvent)处理各种调度算法7、程序主要代码解析由于代码较多，以下只列出了先来先服务算法和最短作业优先算法的代码。
if (nIDEvent == 0) //为先来先服务调度算法{if (((((CListBox *)GetDlgItem(IDC_LIST_RUNPRO))->GetCount())==0) && (ReadyVec.size()!=0)) //如果没有进程运行，先择优先级最高的进入运行{sort(ReadyVec.begin(),ReadyVec.end(),Compare);((CListBox *)GetDlgItem(IDC_LIST_READYPRO))->ResetContent();for (int i = 0; i<ReadyVec.size();i++){CString buf ;buf.Format("%d %s",ReadyVec[i].PID,ReadyVec[i].PName);((CListBox *)GetDlgItem(IDC_LIST_READYPRO))->InsertString(i,buf);}ReadyVec[0].status=0;RunVec.push_back(ReadyVec[0]);tempRunPcb = ReadyVec[0];((CListBox *)GetDlgItem(IDC_LIST_READYPRO))->DeleteString(0);CString buf;buf.Format("%d %s",ReadyVec[0].PID,ReadyVec[0].PName);((CListBox *)GetDlgItem(IDC_LIST_RUNPRO))->AddString(buf);}else if(((((CListBox *)GetDlgItem(IDC_LIST_RUNPRO))->GetCount())!=0) && (ReadyVec.size()!=0)){RunVec[0].WorkTime-=100;if ( RunVec[0].WorkTime <= 0){((CListBox *)GetDlgItem(IDC_LIST_RUNPRO))->ResetContent();m_memSize+= ReadyVec[0].MemCount;runTime = 0;RunVec.clear();vector<PCB>::iterator pos1 = ReadyVec.begin();ReadyVec.erase(pos1);}}else if (((((CListBox *)GetDlgItem(IDC_LIST_RUNPRO))->GetCount())!=0) && (ReadyVec.size()==0)){RunVec[0].WorkTime-=100;if ( RunVec[0].WorkTime <= 0){((CListBox *)GetDlgItem(IDC_LIST_RUNPRO))->ResetContent();m_memSize+= ReadyVec[0].MemCount;runTime = 0;RunVec.clear();vector<PCB>::iterator pos1 = ReadyVec.begin();ReadyVec.erase(pos1);}}if ((((CListBox *)GetDlgItem(IDC_LIST_WAITPRO))->GetCount())!=0){if (WaitVec.size()!=0){sort(WaitVec.begin(),WaitVec.end(),Compare);for (int j = 0;j<WaitVec.size();j++){if (WaitVec[j].MemCount <=m_memSize){//删除掉可以进入就绪队列的优先权最高的进程m_memSize-=WaitVec[j].MemCount;WaitVec[j].status=1;ReadyVec.push_back(WaitVec[j]);vector<PCB>::iterator pos = &WaitVec[j];WaitVec.erase(pos);((CListBox *)GetDlgItem(IDC_LIST_WAITPRO))->DeleteString(j);CString buf;buf.Format("%d %s",ReadyVec[j].PID,ReadyVec[j].PName);((CListBox*)GetDlgItem(IDC_LIST_RUNPRO))->InsertString(ReadyVec.size(),buf);}}((CListBox *)GetDlgItem(IDC_LIST_WAITPRO))->ResetContent();for (j = 0;j<WaitVec.size();j++){CString buf ;buf.Format("%d %s",WaitVec[j].PID,WaitVec[j].PName);((CListBox *)GetDlgItem(IDC_LIST_WAITPRO))->InsertString(j,buf);}}}UpdateData(FALSE);}else if (nIDEvent == 1)//最短作业优先算法{if ((!ReadyVec.empty()) && ((((CListBox *)GetDlgItem(IDC_LIST_RUNPRO))->GetCount())==0)){std::stable_sort( ReadyVec.begin(),ReadyVec.end(),CompareByWkt);((CListBox *)GetDlgItem(IDC_LIST_READYPRO))->ResetContent();for (int i = 0; i<ReadyVec.size(); i++){CString buf ;buf.Format("%d %s",ReadyVec[i].PID,ReadyVec[i].PName);((CListBox *)GetDlgItem(IDC_LIST_READYPRO))->InsertString(i,buf);}ReadyVec[0].status=0;RunVec.push_back(ReadyVec[0]);ReadyVec[0].WorkTime-=100;tempRunPcb = ReadyVec[0];CString buf;((CListBox *)GetDlgItem(IDC_LIST_READYPRO))->GetText(0,buf);((CListBox *)GetDlgItem(IDC_LIST_READYPRO))->DeleteString(0);((CListBox *)GetDlgItem(IDC_LIST_RUNPRO))->AddString(buf);UpdateData(false);}else if (((((CListBox *)GetDlgItem(IDC_LIST_RUNPRO))->GetCount())!=0) && (ReadyVec.size()!=0)){ReadyVec[0].WorkTime-=100;if ( ReadyVec[0].WorkTime <= 0){((CListBox *)GetDlgItem(IDC_LIST_RUNPRO))->ResetContent();UpdateData(false);m_memSize+= ReadyVec[0].MemCount;runTime = 0;RunVec.clear();vector<PCB>::iterator pos1 = ReadyVec.begin();ReadyVec.erase(pos1);}//操作阻塞队列stable_sort(WaitVec.begin(),WaitVec.end(),CompareByWkt);if (WaitVec.size()!=0){if (WaitVec[0].MemCount <= m_memSize){m_memSize-= WaitVec[0].MemCount;WaitVec[0].status=1;ReadyVec.push_back(WaitVec[0]);vector<PCB>::iterator pos = WaitVec.begin();WaitVec.erase(pos);if (ReadyVec.size()!=0){((CListBox *)GetDlgItem(IDC_LIST_READYPRO))->ResetContent();for (int i = 0; i<ReadyVec.size(); i++){CString buf ;buf.Format("%d %s",ReadyVec[i].PID,ReadyVec[i].PName);((CListBox *)GetDlgItem(IDC_LIST_READYPRO))->InsertString(i,buf);}UpdateData(false);}((CListBox *)GetDlgItem(IDC_LIST_WAITPRO))->ResetContent();for (int i = 0; i<WaitVec.size(); i++){CString buf ;buf.Format("%d %s",WaitVec[i].PID,WaitVec[i].PName);((CListBox *)GetDlgItem(IDC_LIST_WAITPRO))->InsertString(i,buf);}UpdateData(FALSE);}}}else if (((((CListBox *)GetDlgItem(IDC_LIST_RUNPRO))->GetCount())!=0) && (ReadyVec.empty())){ReadyVec[0].WorkTime-=100;if ( ReadyVec[0].WorkTime <= 0){((CListBox *)GetDlgItem(IDC_LIST_RUNPRO))->ResetContent();UpdateData(FALSE);m_memSize+= ReadyVec[0].MemCount;runTime = 0;RunVec.clear();}}else{UpdateData(FALSE);}}8、测试数据及测试结果8.1、运行时部分界面刚启动时添加进程后：先来先服务算法调度点击开始模拟后：双击执行进程时：点击阻塞时：8.2、数据测试记录系统内存：10M 时间片：1000进程名称进程ID 进入时间执行时间 优先级 所需内存a 10012000 3 1 b 1002 1000 1 2 c 1003 3000 2 2 d 1004 2000 4 6 e1005500053调度算法 进程执行顺序 先来先服务算法 a,b,c,e,d 最短作业优先算法 b,a,c,e,d 优先级调度算法 e,a,c,b,d时间片轮转法a,b,c,e,a,c,e,c,e,d,e,d,e,d9、设计过程中遇到的问题及解决方法● 满足进程动态生成的需要，使用向量vector 进行存放进程● 向量vector 中的内容不能直接使用下标删除，使用迭代器iterator 并结合函数erase运行时捕捉系统时间，以毫秒为单位使用。