进程调度算法模拟 (操作系统课程设计报告)
(完整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。
操作系统课程设计报告-进程调度的模拟实现
操作系统课程设计报告专业计算机科学与技术学生姓名班级学号指导教师完成日期博雅学院ﻬ题目:进程调度的模拟实现的模拟实现一、设计目的本课程设计是学习完“操作系统原理”课程后进行的一次全面的综合训练，通过课程设计，更好地掌握操作系统的原理及实现方法，加深对操作系统基础理论和重要算法的理解,加强学生的动手能力。
在多道程序和多任务系统中,系统内同时处于就绪状态的进程可能有若干个。
也就是说能运行的进程数大于处理机个数。
为了使系统中的进程能有条不紊地工作,必须选用某种调度策略，选择一进程占用处理机。
要求学生设计一个模拟处理机调度算法,以巩固和加深处理机调度的概念.二、设计内容1)概述选择一个调度算法，实现处理机调度。
设计要求:１)进程调度算法包括：时间片轮转法，短作业优先算法，动态优先级算法。
2)可选择进程数量3)本程序包括三种算法,用C或Ｃ++语言实现，执行时在主界面选择算法(可用函数实现），进入子页面后输入进程数,（运行时间，优先数由随机函数产生),执行，显示结果。
调度时总是选取优先数最大的进程优先运行２．每个进程的优先数，运行时间，由程序任意指定.3．为了调度方便,把进程按给定优先级(动态优先级算法中）从小到大排成一个队列。
按给定运行时间（短作业优先）从小到大排成一个队列用一个变量作为队首指针,指向队列的第一个进程。
4．处理机调度总是选队首进程运行。
由于本实验是模拟处理机调度，所以被选中的进程并不实际的启动运行，而是执行:优先数－1（动态优先级算法中)要求运行时间－1来模拟进程的一次运行。
5.进程运行一次后，若要求运行时间不等于０,则再将它加入队列（动态优先级算法中:按优先数大小插入.)，且改变队首指针：若要求运行时间=0，则把它的状态改为完成（C)状态,且退出队列。
（5)对于遇到优先数一致的情况,采用FIFO策略解决.3。
概要设计(1)本程序用两种算法对五个进程进行调度,每个进程可有三个状态,并假设初始状态为就绪状态。
进程调度算法模拟实验报告
竭诚为您提供优质文档/双击可除进程调度算法模拟实验报告篇一：操作系统进程调度算法模拟实验报告进程调度算法模拟专业：xxxxx学号：xxxxx姓名：xxx实验日期：20xx年xx月xx日一、实验目的通过对进程调度算法的模拟加深对进程概念和进程调度算法的理解。
二、实验要求编写程序实现对5个进程的调度模拟，要求至少采用两种不同的调度算法分别进行模拟调度。
三、实验方法内容1.算法设计思路将每个进程抽象成一个控制块pcb，pcb用一个结构体构建一个进程调度类。
将进程调度的各种算法分装在一个类中。
类中存在三个容器，一个保存正在或未进入就绪队列的进程，一个保存就绪的进程，另一个保存已完成的进程。
还有一个pcb实例。
主要保存正在运行的进程。
类中其他方法都是围绕这三个容器可以这个运行中的pcb展开。
主要用到的技术是sTL中的vector以维护和保存进程容器、就绪容器、完成容器。
当程序启动时，用户可以选择不同的调度算法。
然后用户从控制台输入各个进程的信息，这些信息保存到进程容器中。
进程信息输入完毕后，就开始了进程调度，每调度一次判断就绪队列是否为空，若为空则系统时间加一个时间片。
判断进程容器中是否有新的进程可以加入就绪队列。
2.算法流程图主程序的框架：();//先来先服务();//最短进程优先调度//简单时间片轮转//最高优先数优先//输入进程信息();.m_waitQueue.empty()||.m_processQueue.empt() ();进程调度过程：;3.算法中用到的数据结构structfcfs{//先来先服务算法从这里开始charname[10];floatarrivetime;floatservicetime;float starttime;floatfinishtime;floatzztime;floatdqzztime;};//定义一个结构体，里面包含的有一个进程相关的信息4.主要的常量变量vector m_processQueue;//进程输入队列vector m_waitQueue;//进程就绪队列vectorm_FinishQueue;//完成队列vect(:进程调度算法模拟实验报告)or ::iteratorm_iter;//迭代器pcbm_runprocess;//运行中的进程intm_processcount;//进程数floatm_RunTime;//运行时间intm_tagIsRun;//是否在运行标志。
操作系统进程调度算法模拟实验报告
操作系统进程调度算法模拟实验报告一、实验目的本实验旨在深入理解操作系统的进程调度算法，并通过模拟实验来探究不同调度算法之间的差异和优劣。
二、实验原理操作系统的进程调度算法是决定进程执行顺序的重要依据。
常见的调度算法有先来先服务（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）算法的平均等待时间最短，说明该算法在短作业的情况下能够有效地减少等待时间。
操作系统进程调度模拟课程设计(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。
【精品】进程调度算法模拟实验报告
【精品】进程调度算法模拟实验报告一、实验目的本实验通过模拟进程的调度算法，使学生掌握多种进程调度算法的实现过程及其优缺点。
二、实验内容本实验实现了三种进程调度算法：先来先服务（First Come First Served，FCFS）、最短作业优先（Shortest Job First，SJF）、时间片轮转（Round Robin，RR）。
（一）FCFS算法FCFS算法是一种非抢占式的进程调度算法，按照进程到达的先后顺序进行执行，即先到达的进程先被执行，后到达的进程后被执行。
当一个进程在执行过程中发生等待时，其他新到达的进程会继续执行。
等待时间长的进程会长时间等待，造成了响应时间长的问题。
SJF算法是一种动态优先级的进程调度算法，按照进程预计运行时间的大小来决定其优先级，预计运行时间短的进程具有高优先级。
当一个新进程到达时，如果其预计运行时间比当前正在运行的所有进程都短，那么这个新进程就可以立即执行。
该算法在保证短作业优先的同时，可能会导致长作业饥饿的问题。
（三）RR算法RR算法是一种抢占式的进程调度算法，每个进程被分配一个时间片，当一个进程的时间片用完时，就被剥夺CPU，然后排到队列的末尾，等待下一次调度。
该算法能够保证每个进程的响应时间比较短，但可能会导致CPU利用率较低。
三、实验步骤（一）编写程序框架首先，根据实验要求，编写完整的程序框架，包括进程类Process和调度器类Scheduler。
Process类中包含了进程需要的属性和方法，如进程ID、进程到达时间、进程执行时间、进程状态等。
Scheduler类中包含了进程调度所需要的方法，如FCFS、SJF、RR 调度算法等。
（二）实现进程调度算法FCFS算法较为简单，只需要按照进程到达时间排序即可。
```pythondef FCFS(self):queue = Queue()process_time = 0while not self.is_finished():ready_process = self.get_arrived_process(process_time)if ready_process:queue.put(ready_process)if not queue.empty():current_process = queue.get()current_process.status = 'running'current_process.start_time = process_timecurrent_process.end_time = current_process.start_time + current_process.run_timeself.finished_processes.append(current_process)process_time += 1```2. SJF算法SJF算法需要进行进程预计运行时间的排序，然后按照排序后的顺序进行执行。
进程调度算法模拟实验报告
计算机综合实验报告课程名称操作系统实验学期至学年第学期学生所在系部年级专业班级学生姓名学号任课教师实验成绩信息科学与技术系制实验报告须知1 学生上交实验报告时，必须为打印稿（A4纸）。
页面空间不够，可以顺延。
2 学生应该填写的内容包括：封面相关栏目、实验地点、时间、目的、设备环境、内容、结果及分析等。
3 教师应该填写的内容包括：实验成绩、教师评价等。
《操作系统》课程实验报告int time;//需要在cpu上处理的时间struct node* next;//链指针}PCB;3.实验代码（要求加注释）void insert1(PCB *p,PCB *queue){PCB *q;q=queue;while(q->next)q=q->next;q->next=p;p->next=NULL;}//先来先服务把进程p插入就绪或等待队列的尾部void creat1(int n){PCB *p;int i;ready=new PCB;ready->next=NULL;wait=new PCB;wait->next=NULL;//带头结点的队列run=NULL;for(i=1;i<=n;i++){p=new PCB;cout<<endl<<"请输入进程名称：";cin>>p->name;cout<<"进程状态：";p->state=rand()%2;cout<<p->state;cout<<endl;if(p->state==0)insert1(p,ready);//当state为0时，插入到就绪队列中elseinsert1(p,wait);//否则插入到等待队列中}}void runing(){PCB *p;cout << "当前执行进程：";if(!run)cout<<"空"<<endl<<"就绪队列：";elsecout<<run->name<<endl<<"就绪队列：";if(!ready->next)cout<<"空";elsefor(p=ready->next;p;p=p->next)cout<<p->name<<" ";cout<<endl<<"等待队列：";if(!wait->next)cout<<"空";elsefor(p=wait->next;p;p=p->next)cout<<p->name<<" ";cout<<endl;}void FCFS(int n){srand((int)time(0));int state_change;PCB *p;cout<<endl<<"*********先来先服务*************************"<<endl;creat1(n);srand((int)time(0));cout<<endl<<"运行前："<<endl;runing();cout<<endl;cout<<"运行中："<<endl;while(ready->next||wait->next){if(ready->next){run=ready->next;ready->next=run->next;}runing();state_change=rand()%2;cout<<endl<<"state_change="<<state_change<<endl;if(state_change==1&&wait->next){p=wait->next;wait->next=p->next;insert1(p,ready);}run=NULL;}cout<<endl;}//********************************************************************** void insert2(PCB *p,PCB *queue){PCB *q,*preq;preq=queue;q=queue->next;while(q&&(q->prio)<=(p->prio)){preq=q;q=q->next;}if(!q){preq->next=p;p->next=NULL;}else{p->next=q;preq->next=p;}}//把p插入优先级队列中，队列仍然按照优先级高低排列void creat2(int n){srand((int)time(0));PCB *p;run=NULL;for(int i=0;i<n;i++){p=new PCB;cout<<endl<<"请输入进程名称：";cin>>p->name;cout<<"进程状态：";p->state=rand()%2;cout<<p->state;cout<<endl<<"进程的优先级：";p->prio=rand()%5+1;cout<<p->prio;cout<<endl<<"进程需要的执行时间：";p->time=rand()%10+1;cout<<p->time;cout<<endl;if(p->state==0)insert2(p,ready);//当state为0时，插入到就绪队列中elseinsert1(p,wait);//否则插入到等待队列中}}void FPF(int n){srand((int)time(0));int wait_state_change,run_state_change,cpu_time=rand()%5+1;//cpu_time表示一次在cpu上的执行时间PCB *p;cout<<"************高优先级********************************"<<endl<<"cpu_time="<<cpu_time;creat2(n);srand((int)time(0));cout<<endl<<"运行前："<<endl;runing();cout<<endl;cout<<"运行中："<<endl;while(ready->next||wait->next){if(ready->next){run=ready->next;ready->next=run->next;}runing();wait_state_change=rand()%2;cout<<"wait_state_change="<<wait_state_change<<endl;if(wait_state_change==1&&wait->next){p=wait->next;wait->next=p->next;insert1(p,ready);}if(run&&run->time>cpu_time){run->time-=cpu_time;run_state_change=rand()%2;cout<<"run_state_change="<<run_state_change<<endl;if(run&&run_state_change==0&&run->time>0)insert1(run,ready);elseinsert1(run,wait);}else run=NULL;}cout<<endl;}//********************************************************************** void insert3(PCB *p,PCB *queue){PCB *q,*preq;preq=queue;q=queue->next;while(q&&(q->time)<=(p->time)){preq=q;q=q->next;}if(!q){preq->next=p;p->next=NULL;}else{p->next=q;preq->next=p;}}//把p插入作业按时间排列的队列中，队列仍然按照时间长短排列void creat3(int n){srand((int)time(0));PCB *p;run=NULL;for(int i=0;i<n;i++){p=new PCB;cout<<"请输入进程名称：";cin>>p->name;cout<<"进程状态：";p->state=rand()%2;cout<<p->state;cout<<endl<<"进程需要的执行时间：";p->time=rand()%10+1;cout<<p->time;cout<<endl<<endl;if(p->state==0)insert3(p,ready);//当state为0时，插入到就绪队列中elseinsert1(p,wait);//否则插入到等待队列中}}void SPF(int n){srand((int)time(0));int state_change;PCB *p;cout<<"***********短作业优先*******************************"<<endl;creat3(n);cout<<endl<<"运行前："<<endl;runing();srand((int)time(0));cout<<endl<<"运行中："<<endl;while(ready->next||wait->next){if(ready->next){run=ready->next;ready->next=run->next;}runing();state_change=rand()%2;cout<<endl<<"state_change="<<state_change<<endl;if(state_change==1&&wait->next){p=wait->next;wait->next=p->next;insert1(p,ready);}run=NULL;}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
福建农林大学计算机与信息学院课程设计报告课程名称：操作系统实习题目：进程调度算法模拟姓名：系：计算机科学与技术系专业：计算机科学与技术年级：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。
进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。
进程已占用CPU时间CPUTIME。
进程还需占用的CPU时间ALLTIME。
当进程运行完毕时，ALLTIME变为0。
进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进入阻塞状态。
进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个时间片后，将转换成就绪状态。
进程状态STATE。
队列指针NEXT，用来将PCB排成队列。
（3）优先数改变的原则：进程在就绪队列中呆一个时间片，优先数增加1。
进程每运行一个时间片，优先数减3。
（4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。
3.4系统流程图及各模块（1）先来先服务算法 FCFS先来先服务调度算法是一种最简单的调度算法，该算法既可以用于作业调度，也可用于进程调度。
当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将他们调入内存，为它们分配资源、创建进程，然后放入就绪队列。
在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。
该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。
FCFS算法比较有利于长作业（进程），而不利于短作业（进程）。
先来先服务算法流程图：（2）短进程优先算法 SPF短进程（SPF）调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机再重新调度。
SJ(P)F调度算法能有效地降低作业（进程）的平均等待时间，提高系统吞吐量。
该算法对长作业不利，完全未考虑作业的紧迫程度。
短进程优先算法流程图：（3）时间片轮转法 RR在时间片轮转算法中，系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。
当执行的时间片用完时，由一个计数器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。
这样就可以保证就绪队列中的所有进程在一给定的时间内均能获得一时间片的处理机执行时间。
换言之，系统能在给定的时间内响应所有用户的请求。
时间片轮转算法流程图：进程结束3.5程序调试情况1.先来先服务算法运行结果2.短进程优先算法运行结果：3.时间片轮转算法运行结果4.总结本课程设计是学习完“计算机操作系统”课程后进行的一次全面的综合训练，通过课程设计，让我更好地掌握操作系统的原理及实现方法，加深了我对操作系统基础理论和重要算法的理解。
课程设计是我们专业课程知识综合应用的实践训练，也是为我们以后的工作夯实基础。
通过改程序对操作系统的基础知识了解得更透彻了，同时对磁盘调度的四种算法——先来先服务算法，短进程优先调度算法，时间片轮转调度算法，动态优先级调度有了更深刻的理解和掌握，使我能够为进程调度选择适当的算法，提高CPU工作效率。
进行进程调度程序设计的过程中，得到老师的大力指导和同学的支持，在此向他们表示感谢。
经过自己的动手操作和同学老师的指导我成功的做出了课程设计自己感到很高兴。
在整个过程中自己也感受到了集体团结的力量，今后无论是在工作还是学习中我都会发样这种精神。
参考文献[1]计算机操作系统(第3版)，汤小丹，西安电子科技大学出版社，2007年7月[2]C语言程序设计，孟庆昌，人民邮电出版社，2006年4月下面给出的是用C实现程序的源代码：#include<stdio.h>#include <stdlib.h>#include <time.h>#include <conio.h>#include <windows.h>typedef struct pcb{int name;int needtime;int arrivetime;int pri;int state;int cputime;}plist;void action(plist * nowpro);void action(plist * nowpro){Sleep(1000);//将程序的执行暂停一段时间（1000毫秒）printf(" 进程 %d 正在运行",nowpro->name);nowpro->needtime--;if(nowpro->needtime==0){printf(" 进程 %d 结束\n",nowpro->name);/* nowpro->state=1; */printf("-----------------------------\n");}else{printf(" 进程 %d 剩余完成时间 %d\n",nowpro->name,nowpro->needtime);printf("-----------------------------\n");}}void creatpro(int n,plist * process ){int j;for(j=0;j<n;j++){process[j].name= j+1;process[j].needtime=rand()%10+1;process[j].arrivetime=rand()%10;process[j].pri=rand()%4;process[j].state=0;process[j].cputime=0;}}void show( int n,plist * process){int j;for (j=0 ;j<n;j++){printf(" 进程 %d\t",process[j].name);printf(" 剩余完成时间 %d\t",process[j].needtime); printf(" 到达时间 %d\t",process[j].arrivetime); printf(" 优先级 %d\t",process[j].pri);printf(" 状态 %d\t",process[j].state);printf(" cputime %d\n",process[j].cputime);}}void main(){void creatpro(int n,plist * process );void show( int n,plist * process);void fcfs(int n,plist * process);void sjf(int n,plist * process);void rr(int n,plist * pro1);int n; /*the number of process*/int k;plist process[10];printf(" 请输入进程个数(1-10)\n");scanf("%d",&n);creatpro(n,process);show(n,process);printf(" 请选择所需要的调度算法 \n");printf("1 FCFS\t 2 SJF\t 3 RR\n");scanf("%d",&k);switch(k){case 1: fcfs(n,process); break;case 2: sjf(n,process); break;case 3: rr(n,process); break;default : break;}getch();}void fcfs(int n,plist * pro1){void show( int n,plist * process);int i,j,k;int m=0;int time;plist temp;plist pro2[10];for(i=0;i<n;i++){k=0;while(pro1[k].state==1){k++;}temp=pro1[k];for(j=k+1;j<n;j++){if(temp.arrivetime>pro1[j].arrivetime&&pro1[j].state!=1) {temp=pro1[j];k=j;}}pro2[m++]=temp;pro1[k].state=1;}show(n,pro2);for(i=0;i<n;i++){while(pro2[i].needtime>0){action(&pro2[i]);}}}void sjf(int n,plist * pro1){void show( int n,plist * process);int i,j,k;int m=0;plist temp;plist pro2[10];for(i=0;i<n;i++){k=0;while(pro1[k].state==1){k++;}temp=pro1[k];for(j=k+1;j<n;j++){if(temp.needtime>pro1[j].needtime&&pro1[j].state!=1) {temp=pro1[j];k=j;}}pro2[m++]=temp;pro1[k].state=1;}show(n,pro2);for(i=0;i<n;i++){while(pro2[i].needtime>0){action(&pro2[i]);}}}void rr(int n,plist * pro1){void show( int n,plist * process);int i,j,k;int m=0;int time;plist temp;plist pro2[10];for(i=0;i<n;i++){k=0;while(pro1[k].state==1){k++;}temp=pro1[k];for(j=k+1;j<n;j++){if(temp.arrivetime>pro1[j].arrivetime&&pro1[j].state!=1){temp=pro1[j];k=j;}}pro2[m++]=temp;pro1[k].state=1;}show(n,pro2);time=pro2[0].needtime;for(i=0;i<n;i++){if(time<pro2[i].needtime){time=pro2[i].needtime;}}while(time>0){for(i=0;i<n;i++){if(pro2[i].needtime>0){action(&pro2[i]);}}time--;}}int cal(int a ,plist * pro2){int pr;if((a-pro2->arrivetime)<=0){ pr=1; }else{pr=(a-pro2->arrivetime+pro2->needtime)/pro2->needtime; }return pr;}。