模拟进程调度功能的设计与实现操作系统课程设计(含源文件)
操作系统课程设计报告-进程调度的模拟实现
操作系统课程设计报告专业计算机科学与技术学生姓名班级学号指导教师完成日期博雅学院ﻬ题目:进程调度的模拟实现的模拟实现一、设计目的本课程设计是学习完“操作系统原理”课程后进行的一次全面的综合训练，通过课程设计，更好地掌握操作系统的原理及实现方法，加深对操作系统基础理论和重要算法的理解,加强学生的动手能力。
在多道程序和多任务系统中,系统内同时处于就绪状态的进程可能有若干个。
也就是说能运行的进程数大于处理机个数。
为了使系统中的进程能有条不紊地工作,必须选用某种调度策略，选择一进程占用处理机。
要求学生设计一个模拟处理机调度算法,以巩固和加深处理机调度的概念.二、设计内容1)概述选择一个调度算法，实现处理机调度。
设计要求:１)进程调度算法包括：时间片轮转法，短作业优先算法，动态优先级算法。
2)可选择进程数量3)本程序包括三种算法,用C或Ｃ++语言实现，执行时在主界面选择算法(可用函数实现），进入子页面后输入进程数,（运行时间，优先数由随机函数产生),执行，显示结果。
调度时总是选取优先数最大的进程优先运行２．每个进程的优先数，运行时间，由程序任意指定.3．为了调度方便,把进程按给定优先级(动态优先级算法中）从小到大排成一个队列。
按给定运行时间（短作业优先）从小到大排成一个队列用一个变量作为队首指针,指向队列的第一个进程。
4．处理机调度总是选队首进程运行。
由于本实验是模拟处理机调度，所以被选中的进程并不实际的启动运行，而是执行:优先数－1（动态优先级算法中)要求运行时间－1来模拟进程的一次运行。
5.进程运行一次后，若要求运行时间不等于０,则再将它加入队列（动态优先级算法中:按优先数大小插入.)，且改变队首指针：若要求运行时间=0，则把它的状态改为完成（C)状态,且退出队列。
（5)对于遇到优先数一致的情况,采用FIFO策略解决.3。
概要设计(1)本程序用两种算法对五个进程进行调度,每个进程可有三个状态,并假设初始状态为就绪状态。
操作系统-进程调度模拟算法附源码)
进程调度模拟算法课程名称：计算机操作系统班级：信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，排到就绪队列尾，等待下一次调度。
操作系统进程调度模拟课程设计(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操作系统之上。
进程调度算法的课程设计
进程调度算法的课程设计一、课程目标知识目标：1. 学生能理解进程调度算法的基本概念，掌握其分类和各自特点。
2. 学生能描述并分析不同进程调度算法的优缺点及其适用场景。
3. 学生能运用进程调度算法解决实际问题，如进程优先级分配、CPU利用率优化等。
技能目标：1. 学生通过案例学习，培养分析问题、解决问题的能力，能设计简单的进程调度算法。
2. 学生能运用所学知识，对实际操作系统中的进程调度进行模拟和优化。
3. 学生能运用图表、流程图等工具，清晰、有条理地展示进程调度算法的过程。
情感态度价值观目标：1. 学生培养对计算机操作系统及进程调度算法的兴趣，激发探索计算机科学领域的热情。
2. 学生通过学习进程调度算法，认识到优化算法对提高计算机系统性能的重要性，增强社会责任感和创新意识。
3. 学生通过小组合作学习，培养团队协作精神，提高沟通、交流能力。
课程性质：本课程为计算机科学领域的基础课程，主要研究操作系统中进程调度算法的原理及其应用。
学生特点：学生已具备一定的计算机操作基础，对操作系统有初步了解，但进程调度算法较为抽象，需要结合实际案例进行讲解。
教学要求：结合实际案例，采用启发式教学，引导学生主动思考、探索和解决问题。
注重理论与实践相结合，培养学生的实际操作能力和创新意识。
通过小组合作、讨论等形式，提高学生的沟通能力和团队协作精神。
在教学过程中，关注学生的个体差异，因材施教，确保每个学生都能达到课程目标。
二、教学内容1. 进程调度算法概述：介绍进程调度算法的基本概念、目的和重要性。
- 理解进程与线程的区别，掌握进程调度的基本任务。
- 熟悉进程调度算法的分类，如先来先服务、短作业优先、优先级调度等。
2. 先来先服务调度算法（FCFS）：分析算法原理、特点及优缺点。
- 学习FCFS算法的作业排序规则，分析其对作业执行时间的影响。
3. 短作业优先调度算法（SJF）：介绍SJF算法的原理，比较其与FCFS算法的差异。
操作系统进程调度子系统的设计与实现——操作系统课程设计报告
本科学生课程设计任务书课程设计题目操作系统进程调度子系统的设计与实现学院计算机学院专业网络工程年级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]="";}//---------------------------------------------------------------------------六、实验总结：此次实验花了一周多的时间完成了程序的编写和界面设计，这其中也走了不少弯路。
操作系统课程设计进程调度模拟设计
课程设计课程名字系统软件开发实训A题目进程调度模拟设计一一先来先服务、优先级法学院计算机科学与技术学院专业计算机科学与技术专业班级姓名指导教师李玉强2014 年01月13 日天天天天天天课程设计任务书学生姓名： _________ 专业班级： ______________ 指导教师：李玉强工作单位： 计算机科学与技术学院题目：进程调度模拟设计一一先来先服务、优先级法初始条件:1 •预备内容：阅读操作系统的处理机管理章节内容，对进程调度的功能以及进程调度算法有 深入的理解。
2 •实践准备：掌握一种计算机高级语言的使用。
要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）1 •模拟进程调度，能够处理以下的情形：⑴ 能够选择不同的调度算法（要求中给出的调度算法）；⑵ 能够输入进程的基本信息， 如进程名、优先级、到达时间和运行时间等; ⑶根据选择的调度算法显示进程调度队列；⑷ 根据选择的调度算法计算平均周转时间和平均带权周转时间。
2 •设计报告内容应说明： ⑴课程设计目的与功能；⑵需求分析，数据结构或模块说明 （功能与框图）； ⑶ 源程序的主要部分；⑷ 测试用例，运行结果与运行情况分析； ⑸自我评价与总结。
时间安排：设计安排3周：查阅、分析资料 1 系统软件的分析与建模 4系统软件的设计 5 系统软件的实现 3 撰写文档 1课程设计验收答辩1 设计验收安排：设计周的第三周的指定时间到实验室进行上机验收 设计报告书收取时间：课程设计验收答辩完结时。
（注意事项：严禁抄袭，一旦发现，抄与被抄的一律按0分记）指导教师签名：2013 年12月10日系主任(或责任教师)签名：2013 年12月10日课程设计报告书1•需求分析1.1设计目的(1) 阅读操作系统的处理机管理章节内容，对进程调度的功能以及进程调度算法有深入的理解。
(2) 掌握一种计算机高级语言的使用。
要求完成的主要任务：(包括课程设计工作量及其技术要求，以及说明书撰写等具体要求) 1.2程序流程图1.3设计要求(1) 能够选择不同的调度算法(要求中给出的调度算法)；(2) 能够输入进程的基本信息，如进程名、优先级、到达时间和运行时间等;(3) 根据选择的调度算法显示进程调度队列；(4) 根据选择的调度算法计算平均周转时间和平均带权周转时间。
操作系统课程设计报告模拟进程调度程序(一)
操作系统课程设计报告模拟进程调度程序(一) 此设计报告是对操作系统中进程调度的两种算法，即静态优先权调度算法和需要时间片的转法进行了描述，并分析了它们的工作机理。
最高优先权调度算法的基本思想是把CPU分配给就绪队列中优先权最高的进程。
静态优先数是在创建进程时确定的，并在整个进程运行期间不再改变。
简单轮转法的基本思想是：所有就绪进程按FCFS排成一个队列，总是把处理机分配给队首的进程，各进程占用CPU的时间片相同。
如果运行进程用完它的时间片后还未完成，就把它送回到就绪队列的末尾，把处理机重新分配给队首的进程，直至所有的进程运行完毕。
然后用具体语言模拟了一个进程调度的程序。
用户可以自己输入产生进程，然后选择调度方式进行调度。
所用的语言为，结果显示了调度运行过程。
问题描述和分析………………………………………………4算法设计............................................................5源代码及说明.........................................................5结果与分析...............................................................17参考文献 (18)一、问题描述和分析问题描述CPU调度是多道程序操作系统的基础，几乎所有计算机资源在使用前都要被调度，因此，CPU调度对于操作系统来说非常重要。
假如操作系统中存在若干进程，这些进程，将会被按照指定的调度方式，由CPU进行调度。
本程序，用来模拟实现操作系统中的两种调度方法，即：优先权调度和轮转法调度。
下面对四种调度方法进行描述优先权调度（priority-schedulingalgorithm）：在这种方式下，每一个进程都有一个优先权与其关联，具有最高优先权的进程会被分配到CPU，具有相同优先权的进程按FCFS顺序调度。
操作系统课程设计——进程调度模拟算法(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先到先服务算法描述：把所有进程按到达先后排序，每次取最先到的进程执行后淘汰，再取下一个，直到所有进程调度完毕。
操作系统进程调度模拟算法附源码
先来先服务（FCFS）
定义：按照进程到 达的先后顺序进行 调度
优点：实现简单， 适用于CPU繁忙型 进程
缺点：等待时间较 长，可能导致饥饿 现象
适用场景：适用于 CPU密集型进程， 不适用于I/O密集 型进程
最短作业优先（SJF）
定义：按照作业的估计运行时间进行排序，选择最短作业优先执行 优点：响应时间快，作业平均等待时间少 缺点：存在饥饿现象，长作业可能长时间得不到执行 适用场景：适用于作业量较大且作业到达时间间隔较长的情况
Part Five
模拟实验结果及分 析
实验环境及参数设置
处理器：Intel Core i78700K
操作系统：Linux
内存：16GB DDR4 硬盘：256GB SSD
实验结果展示
实验数据：模拟算法在不同情况下的运行结果 数据分析：对实验数据进行分析，得出结论 结果对比：将模拟算法与实际操作系统进行对比，分析差异 结果展示：以图表、表格等形式展示实验结果
优先级调度算法
定义：根据进 程的优先级进 行调度，优先 级高的进程优 先获得处理器
资源
分类：静态优 先级调度算法 和动态优先级
调度算法
静态优先级调 度算法：优先 级在进程创建 时就确定，且 在运行过程中
保持不变
动态优先级调 度算法：优先 级根据进程的 行为和需求动
态调整
轮转法（RR）
定义：轮转法是 一种简单且常用 的进程调度算法， 也称为循环调度
算法。
原理：按照进程 到达的先后顺序， 按照固定的时间 片进行循环调度。
特点：每个进程 分配一个固定时 间片，时间片用 完后自动切换到 下一个进程，如 果时间片未用完， 则一直运行直到
进程模拟课程设计
进程模拟课程设计一、课程目标知识目标：1. 学生能理解进程模拟的基本概念，掌握进程的基本状态和转换条件。
2. 学生能够运用流程图、伪代码等方式描述进程的运行过程。
3. 学生了解操作系统中进程管理的基本原理，并能够解释进程调度、同步和互斥等相关知识。
技能目标：1. 学生能够运用所学知识，设计简单的进程模拟程序，实现进程的创建、运行和终止。
2. 学生通过实际操作，学会使用至少一种编程工具进行进程模拟，提高编程实践能力。
3. 学生能够分析并解决进程管理中可能出现的问题，如死锁、饥饿等。
情感态度价值观目标：1. 培养学生对计算机科学和操作系统的兴趣，激发他们探索未知、积极进取的精神。
2. 增强学生的团队合作意识，使他们学会在团队中沟通、协作，共同完成任务。
3. 培养学生严谨、务实的科学态度，让他们认识到进程管理在计算机系统中的重要性。
本课程针对年级学生的认知特点和学科要求，以实际操作为导向，注重理论与实践相结合。
通过本课程的学习，学生将掌握进程模拟的基本知识和技能，培养他们解决实际问题的能力，同时提升对计算机科学的兴趣和情感态度。
为实现课程目标，后续教学设计和评估将围绕具体学习成果展开，确保教学效果的达成。
二、教学内容本课程教学内容以《计算机操作系统》教材中进程管理章节为基础，涵盖以下要点：1. 进程基本概念：进程的定义、进程与程序的区别、进程的属性。
2. 进程状态及转换：运行、就绪、阻塞状态，状态转换条件。
3. 进程控制块（PCB）：作用、内容、管理方式。
4. 进程调度：进程调度算法，如FCFS、SJF、优先级调度等。
5. 进程同步与互斥：同步机制、互斥概念、生产者-消费者问题、哲学家就餐问题。
6. 死锁与饥饿：死锁的定义、预防、避免、检测与解除；饥饿现象及其解决方案。
7. 进程通信：进程间通信方式，如管道、消息队列、共享内存等。
教学大纲安排如下：第一课时：进程基本概念、进程状态及转换。
第二课时：进程控制块、进程调度。
进程调度实验报告源码
一、实验目的本次实验旨在通过模拟进程调度过程，加深对进程调度算法的理解，并掌握进程调度程序的设计与实现方法。
实验内容主要包括：创建进程、进程调度、进程执行、进程结束等。
二、实验环境操作系统：Linux编程语言：C/C++三、实验内容1. 进程调度算法本实验采用三种进程调度算法：FIFO（先进先出）、时间片轮转法、多级反馈队列调度算法。
2. 进程调度程序设计进程调度程序主要由以下部分组成：（1）进程控制块（PCB）PCB用于描述进程的基本信息，包括进程名、到达时间、需要运行时间、已运行时间、进程状态等。
（2）就绪队列就绪队列用于存储处于就绪状态的进程，按照进程的优先级或到达时间进行排序。
（3）进程调度函数进程调度函数负责从就绪队列中选择一个进程进行执行，并将CPU分配给该进程。
（4）进程执行函数进程执行函数负责模拟进程的执行过程，包括进程的创建、执行、结束等。
四、实验源码```c#include <stdio.h>#include <stdlib.h>#include <time.h>#define MAX_PROCESSES 10typedef struct PCB {int pid;int arrival_time;int need_time;int used_time;int priority;int state; // 0: 等待 1: 运行 2: 完成} PCB;PCB processes[MAX_PROCESSES];int process_count = 0;typedef struct Queue {PCB queue;int front;int rear;int size;} Queue;Queue ready_queue;void init_queue(Queue q) {q->queue = (PCB )malloc(sizeof(PCB) MAX_PROCESSES); q->front = q->rear = 0;q->size = 0;}void enqueue(Queue q, PCB p) {if (q->size == MAX_PROCESSES) {printf("Queue is full.\n");return;}q->queue[q->rear] = p;q->rear = (q->rear + 1) % MAX_PROCESSES; q->size++;}PCB dequeue(Queue q) {if (q->size == 0) {printf("Queue is empty.\n");return NULL;}PCB p = &q->queue[q->front];q->front = (q->front + 1) % MAX_PROCESSES; q->size--;return p;}int is_empty(Queue q) {return q->size == 0;}void print_queue(Queue q) {printf("Queue: ");for (int i = 0; i < q->size; i++) {PCB p = &q->queue[(q->front + i) % MAX_PROCESSES];printf("PID: %d, Arrival Time: %d, Need Time: %d, Used Time: %d, Priority: %d, State: %d\n",p->pid, p->arrival_time, p->need_time, p->used_time, p->priority, p->state);}}void init_processes() {for (int i = 0; i < MAX_PROCESSES; i++) {processes[i].pid = i;processes[i].arrival_time = rand() % 10;processes[i].need_time = rand() % 10 + 1;processes[i].used_time = 0;processes[i].priority = rand() % 3;processes[i].state = 0;}}void schedule() {int time = 0;while (process_count > 0) {for (int i = 0; i < process_count; i++) {PCB p = &processes[i];if (p->arrival_time == time) {enqueue(&ready_queue, p);p->state = 1;}}if (!is_empty(&ready_queue)) {PCB p = dequeue(&ready_queue);p->used_time++;printf("Process %d is running.\n", p->pid);if (p->used_time == p->need_time) {p->state = 2;printf("Process %d is finished.\n", p->pid); }}time++;}}int main() {srand(time(NULL));init_queue(&ready_queue);init_processes();process_count = rand() % MAX_PROCESSES + 1;schedule();print_queue(&ready_queue);return 0;}```五、实验结果与分析1. FIFO调度算法实验结果表明，FIFO调度算法按照进程的到达时间进行调度，可能导致短作业等待时间长，效率较低。
模拟进程调度功能的设计与实现操作系统课程设计(含源文件)
目录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应用程序的开发。
操作系统课程设计-进程调度的模拟实现
课程设计题目进程调度算法模拟编程学生姓名学号专业计算机科学与技术班级指导教师完成日期2012年12月18日进程调度的模拟实现摘要：进程管理是操作系统中的重要功能，用来创建进程、撤消进程、实现进程状态转换，它提供了在可运行的进程之间复用CPU的方法。
在进程管理中，进程调度是核心，因为在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态，当就绪进程个数大于处理器数目时，就必须依照某种策略决定哪些进程优先占用处理器。
本文通过两种算法模拟实现了进程之间的调度。
关键词：进程创建，先来先服务，优先级调度。
一．前言在操作系统中，调度的实质是一种资源分配，调度算法即指：根据系统的资源分配策略所规定的资源分配算法。
对于不同的系统和系统目标，通常采用不同的调度算法，如在批处理系统中，为照顾为数众多的短作业，采用短作业有限调度算法；在分时系统中，为保证系统具有合理的响应时间，采用轮转法进行调度。
采用算法时，则要考虑多方面因素，以便达到最佳效果。
做好这个课程设计，有利于加深对操作系统进程调度知识的理解。
二. 系统总体框架设计本程序采用两种算法（最高优先级数优先的调度算法和先来先服务算法）对多个进程进行调度，每个进程有三个状态，初始状态为就绪状态。
最高优先级数优先的调度算法中，程序的某进程运行时间以时间片为单位计算。
各进程的优先数或轮转时间数以及进程需运行的时间片数的初始值均由用户给定。
在优先级数优先的调度算法中，优先级数的值设计为100与运行时间的差值，即Pro_time-process->needtime。
进程每执行一次，优先数减3，CPU 时间片数加1，进程还需要的时间片数减1。
对于遇到优先数一致的情况，采用先来先服务策略解决。
程序设计组成框图程序流程图1.可强占优先调度算法实现过程流程图：开始创建进程及属性先来先服务算法 优先数调度算法显示进程执行状态结束2先来先服务调度算法实现过程流图三．数据结构设计1.设计创建进程的结构类型定义和结构变量说明struct ProcessPcb，定义PCB相关变量：ProcessPcb(){next=NULL;}char pro_name[20]; //进程的名字int time_submit ; //提交时间,从时间为1开始计时int time_exe ; //进程所需的运行时间int pro_id ; //进程ID(系统生成)int pro_priority ; //进程优先级int time_start ; //开始执行的时间int time_end ; //结束的时间int time_wait ; //等待的时间int pro_state ; //进程的状态 (就绪，执行，完成)int time_left ; //还需多少时间单位,初始化为所需的执行时间int time_turn ; //周转时间double time_aver ; //带权周转时间2.创建PCB类class CpuModel，定义程序中使用的各函数：CpuModel{CpuModel(){pcbnum=0;}void cpurun(); //cpu模拟运行函数bool GetPcb(); //进程输入函数void ShowPcb(); //将输入的进程展示出来void PriModel(); //可强占的优先进程调度模式void FcfsModel(); //先到先服务调度模式ProcessPcb PcbList[100]; //按提交时间排的未就绪进程队列()}四．测试结果及分析1.开始运行，显示：2.输入进程数，各进程属性：关于提交时间执行时间等，将检测输入是否数字，不是数字即退出程序。
进程调度算法 操作系统课程设计
计算机科学与应用系操作系统原理课程设计报告题目：进程调度算法班级： 0510074姓名： lee hye 专业：计算机科学与技术指导老师： hhh进程调度算法一、实验目的通过优先权法与轮转调度算法的模拟加深对进程概念和进程调度过程的理解，掌握进程状态之间的切换，同时掌握进程调度算法的实现方法和技巧。
二、实验内容1、用C语言或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）进程每运行一个时间片，优先数增加1.4、在调度前，系统中拥有的进程数PCB_number有键盘输入，进初始化后，所有的进程控制块PCB连接成就绪队列。
5、为了清楚的观察诸进程的调度过程，程序应将每个时间片内的进程的情况显示出来。
三、实验步骤1、进程管理程序调式好后，运行进程管理程序（1）输入1选择优先权调度算法模拟。
（2）输入开始进程个数n，创建n个PCB并加入就绪队列ready_queue中。
（3）就绪队列ready_queue不为空，调度就绪队列中第一个进程运行，否则，从闲逛队列idleprocess中调度闲逛进程运行。
（4）在运行过程中，当遇到阻塞，则该进程插入到阻塞队列block_queue 中，且将该进程从ready_queue中删除。
- 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、设计过程中遇到的问题及解决方法 (18)10、结论 (18)10.1、系统实现情况 (18)10.2、系统特点 (18)10.3、设计体会及收获 (18)11、参考资料 (19)模拟进程调度功能的设计与实现1、设计目的意义1.1、目的意义●通过课程设计理解进程调度的概念，深入了解进程控制的功能、进程的创建、删除以及进程各个状态间的转换过程；实现先来先服务、时间片轮转、最短作业优先、优先级调度算法对进程进行的调度过程；通过观察有关的队列结构的内容的动态变化过程深入体会各个调度算法的特点；从而能够更好的巩固从书本上学到的知识。
●编程过程中需要建立队列等结构进行各种操作，通过该次课程设计，我们更加从实用的角度对《数据结构》课程内容进行更深入理解和更熟练的应用。
●使用C++语言进行编程，通过对调度功能的编程实现，不但能有效训练我们对编程语言的熟练使用，还能促进我们独立思考解决问题、以及独立查新获取知识的能力。
1.2、实现目标●一个进程的生命期可以划分为一组状态，这些状态刻画了整个进程。
系统根据PCB结构中的状态值控制过程。
在进程的生命期内，一个进程至少具有5种基本状态，它们是：初始态、执行状态、等待状态、就绪状态和终止状态。
通过系统设计，实现进程相关数据结构的创建和查看功能；实现多种进程调度算法：先来先服务算法、优先级调度算法、时间片轮转法等；实现对执行进程的阻塞，对等待进程的唤醒等功能。
进程的转换过程如下2、设计方案2．1 软硬件环境 ● 硬件设备： PC 机● 软件设备：WINDOWSXP 、Microsoft Visual C++ 6.0 2．2、开发工具● 由于现在使用的操作系统大多数都是微软公司的产品，为了更好更贴近的模拟操作系统中进程调度功能，我们选择使用C++语言，开发平台Microsoft Visual C++ 6.0，借助MFC 来完成应用Windows 应用程序的开发。
另外通过课余时间的学习，对Windows 应用程序的开发过程也有一些了解，很想学以致用，做点使用的东西加深对学习过的知识的理解与吸收。
2.3、思路● 进程根据外界条件的不断变化引起状态的改变，可以利用系统时间片的大小、进程执行时间、进入主存的时间、系统内存大小、以及调度算法的选择来作为条件对进程进行调度。
通过在对话框中添加按钮、文本编辑框、列表等控件，并为控件关联相应的变量和消息函数，实现各个控件内部以及控件之间的协同工作，并使用定时器进行时间的设置，从而完成系统所要求的进程调度工作。
Windows 应用程序，操作系统，计算机硬件之间的相互关系如下：3、程序功能模块设计（程序功能模块划分及层次等）3.1、总体模块3.2、部分模块3.3、详细功能描述●根据需要设置系统内存的大小●选择不同的进度调度算法进行进程调度模拟●设置进程的各种属性值创建进程●根据进程不同的状态放在不同的位置显示进程调度过程中的动态变化情况●在某一时间点击按钮进行进程调度模拟●进程调度模拟过程中可以暂停调度过程，查看进程的状态变化过程●通过双击状态列表中的某个进程可以查看进程的各属性值●对执行进程、就绪进程进行强制“阻塞”操作●对等待进程进行强制“就绪”操作●将没有执行完毕的进程进行强制“杀死”操作4、程序总控流程图(见下页)5、数据结构设计5.2、进程状态结构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、数据测试记录9、设计过程中遇到的问题及解决方法满足进程动态生成的需要，使用向量vector进行存放进程●向量vector中的内容不能直接使用下标删除，使用迭代器iterator并结合函数erase使用。