进程调度模拟设计——先来先服务、强占式短进程优先算法
先来先服务FCFS和短作业优先SJF进程调度算法
先来先服务FCFS和短作业优先SJF进程调度算法FCFS(先来先服务)算法是最简单的进程调度算法之一、它按照进程到达的顺序来分配CPU时间,即先到达的进程先执行。
在FCFS算法中,进程按照它们进入就绪队列的时间排序,随后按照就绪队列的顺序被调度执行。
FCFS算法不考虑进程的执行时间,也不会对进程进行任何优先级排序。
FCFS算法的优点是简单易懂,实现起来非常简单。
但是,FCFS算法有一个明显的缺点是不利于短进程的执行。
当一个长进程到达并占据CPU 资源时,短进程可能要等待很长时间才能执行。
这种情况下,CPU的利用率会较低,响应时间也会较长。
因此,FCFS算法适用于进程的执行时间相对较短且没有明显的优先级关系的场景。
SJF(短作业优先)算法是根据进程的执行时间进行优先级排序的进程调度算法。
在SJF算法中,短进程将会优先执行,而长进程需等待。
当一个进程到达就绪队列时,系统会根据其估计的执行时间大小将其插入到就绪队列的适当位置。
当前执行的进程完成后,下一个执行的是就绪队列中估计执行时间最短的进程。
SJF算法的优点是能够减少平均等待时间,提高系统整体的吞吐量。
由于短进程占用CPU时间较少,因此能够更快地释放CPU资源给其他进程使用,从而减少等待时间。
然而,SJF算法存在一个问题是如何准确估计进程的执行时间。
在实际场景中,准确估计进程的执行时间是很困难的,因此SJF算法很容易出现估计错误,导致长进程等待时间过长。
总结来说,FCFS和SJF都是进程调度算法,但它们有不同的特点和适用场景。
FCFS算法简单易懂,适用于进程执行时间相对较短且没有明显优先级的场景;而SJF算法适用于进程执行时间有较大差异的场景,能够减少平均等待时间。
然而,SJF算法对进程的执行时间要求较高,需要准确估计执行时间,否则可能导致长进程等待时间过长。
在实际应用中,通常会根据具体情况选择不同的调度算法。
例如,在交互式系统中,为了提供更好的用户体验,使用SJF算法能够减少响应时间;而在批处理系统中,FCFS算法通常被用于处理较短的作业。
操作系统实验_先来先服务的调度算法及短作业优先
操作系统实验_先来先服务的调度算法及短作业优先1.引言操作系统的调度算法是指在多进程环境中,操作系统为进程分配CPU 的顺序和策略。
先来先服务(FCFS)调度算法是最简单的调度算法之一,它按照进程到达的顺序为其分配CPU。
而短作业优先(SJF)调度算法是根据进程的执行时间来为其分配CPU,执行时间越短的进程越先执行。
本文将分别介绍FCFS调度算法和SJF调度算法,并对其进行评价和比较。
2.先来先服务(FCFS)调度算法2.1调度原理FCFS调度算法的原理非常简单,按照进程到达的顺序为其分配CPU。
当一个进程进入就绪队列后,如果CPU空闲,则立即为其分配CPU。
如果CPU正忙,则进程进入等待队列,等待CPU空闲后再分配。
在该算法中,进程的运行时间不考虑,只考虑进程到达的时间。
2.2优点与缺点FCFS调度算法的主要优点是实现简单,无需对进程的运行时间进行估计。
但FCFS算法存在一定的缺点。
首先,长作业在短作业前面等待的时间较长,可能导致长作业的响应时间过长。
其次,如果有一个进程出现阻塞或响应时间过长,其后面的进程也会受到影响,造成整个系统的性能下降。
3.短作业优先(SJF)调度算法3.1调度原理短作业优先(SJF)调度算法是根据进程的执行时间来为其分配CPU。
当一个进程进入就绪队列后,如果其执行时间比当前正在运行的进程短,则优先为该进程分配CPU。
如果当前没有运行的进程或者当前运行的进程执行完毕,则立即为该进程分配CPU。
在该算法中,进程的到达时间不考虑,只考虑进程的执行时间。
3.2优点与缺点SJF调度算法的主要优点是可以最大程度地减少平均等待时间,提高系统的吞吐量。
短作业可以快速执行完毕,从而让更多的作业得以执行。
但SJF算法存在一定的缺点。
首先,需要对进程的执行时间有一个准确的估计,对于实时系统或动态系统来说,估计执行时间可能会有一定的误差。
其次,在长作业激增的情况下,短作业可能会一直得不到CPU的分配,造成长时间的等待。
操作系统进程调度算法
操作系统进程调度算法操作系统进程调度算法是操作系统中非常重要的一部分,它负责管理系统中的所有进程,保证它们能够得到合理的处理器时间,提高系统的性能和资源利用率。
常见的进程调度算法有以下几种。
1. 先来先服务(FCFS)调度算法先来先服务(FCFS)调度算法也被称为先进先出(FIFO)算法。
该算法按照进程到达的先后顺序来分配CPU处理器时间,即先到达系统的进程先获得处理器的执行权,后到达的进程排在队列的末尾等待执行。
该算法的优点是简单易懂,适用于CPU使用率不高的情况,但可能会导致长作业效应和一些短作业长时间等待。
2. 最短进程优先(SJF)调度算法最短进程优先(SJF)调度算法是根据进程的执行时间来进行调度的。
它会预估每个进程的运行时间并按照时间排队。
该算法能有效减少平均等待时间,提高系统的运行效率,但可能会受到进程评估和预测能力的影响。
3. 优先级调度算法优先级调度算法通过给每个进程分配优先级,将优先级最高的进程放在队列最前面,优先执行。
该算法通常使用动态优先级,即根据进程运行的时间或其他因素动态地调整优先级。
这种方法可以很好地处理低优先级进程的问题,但可能会导致高优先级任务一直得不到优先执行。
4. 时间片轮转(RR)调度算法时间片轮转(RR)调度算法使用固定的时间片大小,每个进程在时间片内执行一定的时间,此后等待下一个时间片。
当一个进程的时间片用完后,它会被放回队列的末尾,并且下一个进程得到执行,直到所有进程完成。
该算法能够最大限度地平衡每个进程的执行时间和等待时间,但可能会导致一些较长的进程无法及时完成。
操作系统进程调度算法是一项研究复杂性和计算机资源的领域,不同的算法适用于不同的场合,选择正确的算法可以大大提高系统性能,减轻系统开销。
操作系统课设-进程调度模拟设计(先来先服务、优先级法)
cout<<"进程运行时间:";
cin>>r;
cout<<"进程到达时间:";
cin>>a;
cout<<"进程优先级:";
cin>>p;
cout<<endl;
Node *tp;
tp=new Node;
tp->num=n;
tp->name=na;
tp->run_time=r;
tp->arrive_time=a;
<<setw(12)<<"结束时间"<<endl;
while(tp!=NULL){
cout<<" "<<setw(10)<<tp->num<<setw(10)<<tp->name
<<setw(12)<<tp->arrive_time<<setw(12)<<tp->run_time;
cout<<setw(12)<<tp->start_time<<setw(12)<<tp->end_time<<endl;
q->priority=tp->priority;
q->next=NULL;
tp=tp->next;
p=temp;
while( p->next!=NULL && p->next->priority < q->priority){
进程调度模拟设计——先来先服务、优先级法复习过程
进程调度模拟设计——先来先服务、优先级法学号:课程设计题目进程调度模拟设计——先来先服务、优先级法学院计算机科学与技术专业班级姓名指导教师吴利军2013 年 1 月16 日课程设计任务书学生姓名:专业班级:指导教师:吴利军工作单位:计算机科学与技术学院题目: 进程调度模拟设计——先来先服务、优先级法初始条件:1.预备内容:阅读操作系统的处理机管理章节内容,对进程调度的功能以及进程调度算法有深入的理解。
2.实践准备:掌握一种计算机高级语言的使用。
要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要求)1.模拟进程调度,能够处理以下的情形:⑴能够选择不同的调度算法(要求中给出的调度算法);⑵能够输入进程的基本信息,如进程名、优先级、到达时间和运行时间等;⑶根据选择的调度算法显示进程调度队列;⑷根据选择的调度算法计算平均周转时间和平均带权周转时间。
2.设计报告内容应说明:⑴需求分析;⑵功能设计(数据结构及模块说明);⑶开发平台及源程序的主要部分;⑷测试用例,运行结果与运行情况分析;⑸自我评价与总结:i)你认为你完成的设计哪些地方做得比较好或比较出色;ii)什么地方做得不太好,以后如何改正;iii)从本设计得到的收获(在编写,调试,执行过程中的经验和教训);iv)完成本题是否有其他方法(如果有,简要说明该方法);时间安排:设计安排一周:周1、周2:完成程序分析及设计。
周2、周3:完成程序调试及测试。
周4、周5:验收、撰写课程设计报告。
(注意事项:严禁抄袭,一旦发现,一律按0分记)指导教师签名:年月日系主任(或责任教师)签名:年月日进程调度模拟设计——先来先服务、优先级法1、背景:当计算机系统是多道程序设计系统时,通常会有多个进程或线程同时竞争CPU。
只要有两个或更多的进程处于就绪状态,这种情形就会发生。
如果只有一个CPU可用,那么就必须选择下一个要运行的进程。
在操作系统中,完成选择工作的这一部分称为调度程序,该程序使用的算法成为调度算法。
作业调度算法先来先服务算法短作业算法页
作业调度算法: 先来先服务算法、短作业优先算法引言在计算机操作系统中,作业调度算法是一种重要的技术,用于管理和调度计算机系统中的作业。
作业调度算法决定了如何分配计算机资源,以便最大化系统的效率和吞吐量。
本文将介绍两种常见的作业调度算法:先来先服务算法(First Come First Serve,FCFS)和短作业优先算法(Shortest Job First,SJF)。
先来先服务算法(FCFS)先来先服务算法是最简单的作业调度算法之一。
按照作业提交的顺序进行调度,先提交的作业先执行,后提交的作业则等待。
这种调度算法不考虑作业的执行时间或优先级,只根据作业提交的先后顺序来进行调度。
算法流程1.将作业按照提交的先后顺序排列。
2.按照排列顺序执行作业。
优点•算法实现简单,易于理解和实现。
•适用于短作业或者作业提交顺序代表了作业的优先级的情况。
缺点•短作业可能因为长作业的存在而等待时间过长,导致响应时间较长。
•不考虑作业执行时间,可能导致平均等待时间和平均周转时间较长。
•无法适应不同作业的执行时间需求。
短作业优先算法(SJF)短作业优先算法是一种将作业按照执行时间长度进行排序的作业调度算法。
在短作业优先算法中,最短执行时间的作业先执行,以此类推。
该算法可以最大程度地减少作业的等待时间和周转时间。
算法流程1.将作业按照执行时间长度从短到长进行排序。
2.按照排列顺序执行作业。
优点•可以最大程度地减少作业的等待时间和周转时间。
•适用于短作业和长作业相互混合的情况。
缺点•难以准确估计作业的执行时间,可能导致长作业等待时间过长。
•需要预先知道作业的执行时间长度才能进行排序。
•不适用于长作业占主导地位的情况。
性能对比与选择先来先服务算法和短作业优先算法都有其优点和缺点。
选择合适的算法取决于具体的应用场景和需求。
•如果作业都很短,并且没有严格的截止时间要求,先来先服务算法可以简单高效地满足需求。
•如果作业的执行时间非常重要,并且具有较严格的截止时间要求,短作业优先算法可以最大程度地减少作业的等待时间和周转时间。
进程调度模拟设计——先来先服务、优先级法教材
学号:课程设计进程调度模拟设计——先来题目先服务、优先级法学院计算机科学与技术专业班级姓名指导教师吴利军2013 年 1 月16 日课程设计任务书学生姓名:专业班级:指导教师:吴利军工作单位:计算机科学与技术学院题目: 进程调度模拟设计——先来先服务、优先级法初始条件:1.预备内容:阅读操作系统的处理机管理章节内容,对进程调度的功能以及进程调度算法有深入的理解。
2.实践准备:掌握一种计算机高级语言的使用。
要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要求)1.模拟进程调度,能够处理以下的情形:⑴能够选择不同的调度算法(要求中给出的调度算法);⑵能够输入进程的基本信息,如进程名、优先级、到达时间和运行时间等;⑶根据选择的调度算法显示进程调度队列;⑷根据选择的调度算法计算平均周转时间和平均带权周转时间。
2.设计报告内容应说明:⑴需求分析;⑵功能设计(数据结构及模块说明);⑶开发平台及源程序的主要部分;⑷测试用例,运行结果与运行情况分析;⑸自我评价与总结:i)你认为你完成的设计哪些地方做得比较好或比较出色;ii)什么地方做得不太好,以后如何改正;iii)从本设计得到的收获(在编写,调试,执行过程中的经验和教训);iv)完成本题是否有其他方法(如果有,简要说明该方法);时间安排:设计安排一周:周1、周2:完成程序分析及设计。
周2、周3:完成程序调试及测试。
周4、周5:验收、撰写课程设计报告。
(注意事项:严禁抄袭,一旦发现,一律按0分记)指导教师签名:年月日系主任(或责任教师)签名:年月日进程调度模拟设计——先来先服务、优先级法1、背景:当计算机系统是多道程序设计系统时,通常会有多个进程或线程同时竞争CPU。
只要有两个或更多的进程处于就绪状态,这种情形就会发生。
如果只有一个CPU可用,那么就必须选择下一个要运行的进程。
在操作系统中,完成选择工作的这一部分称为调度程序,该程序使用的算法成为调度算法。
先来先服务和短进程优先调度算法模拟课程设计
先来先服务和短进程优先调度算法模拟课程设计在先来先服务调度算法中,我们按照进程队列的顺序进行调度。
即从队列的头部取出一个进程,分配给CPU进行执行。
当该进程执行完毕后,再从队列的头部取出下一个进程执行。
直到所有的进程都执行完毕,这个调度过程结束。
在短进程优先调度算法中,我们需要根据进程的执行时间来确定调度顺序。
即在进程队列中,找到执行时间最短的进程,将其分配给CPU进行执行。
当该进程执行完毕后,再在剩余的进程中选择执行时间最短的进程进行执行,以此类推。
直到所有的进程都执行完毕,这个调度过程结束。
在模拟的过程中,我们可以记录每个进程的执行时间、等待时间和周转时间等统计信息。
进程的执行时间等于进程的开始执行时间到进程完成执行的时间差。
进程的等待时间等于进程开始执行的时间减去进程到达的时间。
进程的周转时间等于进程完成执行的时间减去进程到达的时间。
通过对以上两种调度算法的模拟,我们可以得到每个进程的执行情况和整个系统的性能指标。
通过对比不同进程到达时间和执行时间的情况,可以分析出不同算法对系统性能的影响。
值得注意的是,以上模拟过程中假设进程没有I/O等待和中断等情况。
在实际操作系统中,这些因素会对进程的调度产生影响。
本次课程设计不仅加深了对先来先服务和短进程优先调度算法的理解,还通过模拟的方式对算法的优劣进行了评估。
通过对不同算法的比较,可以帮助我们更好地了解和选择适合的调度算法,以提高系统的性能和效率。
在本次课程设计中,我们还可以进一步完善模拟过程,添加更多的功能和优化方法,以更加真实地模拟先来先服务和短进程优先调度算法的运行过程。
首先,我们可以考虑引入抢占式调度方式。
在现实的操作系统中,进程的执行可能会被中断,例如由于I/O请求的到来或是优先级更高的进程的到达。
因此,我们可以在模拟中引入抢占式调度,即一个正在执行的进程可以被其他优先级更高的进程抢占执行。
其次,我们可以考虑引入进程的优先级调度。
在实际操作系统中,不同进程可能具有不同的优先级。
进程调度模拟设计——先来先服务最高响应比优先调度算法
进程调度模拟设计——先来先服务最高响应比优先调度算法进程调度是操作系统中非常重要的一部分,它负责根据一定的调度算法从就绪态的进程队列中选择下一个运行的进程。
在这篇文章中,我将介绍两种常见的进程调度算法:先来先服务调度(FCFS)和最高响应比优先调度(HRRN)。
1.先来先服务调度(FCFS):先来先服务调度算法是一种非抢占式调度算法,按照进程到达的顺序依次进行调度。
即当一个进程到达后,它将被插入到就绪队列的末尾。
当前运行的进程执行完毕后,将选择队列中的第一个进程来执行。
先来先服务调度算法的优点是简单、公平,不会发生饥饿现象。
然而,它有一个显著的缺点,即无法考虑进程的执行时间和优先级。
如果一个长时间运行的进程到达了队列,所有其他进程都要等待它完成,这可能导致其他进程的等待时间较长。
2.最高响应比优先调度(HRRN):最高响应比优先调度算法是一种动态优先级调度算法,它考虑了进程的等待时间和执行时间。
响应比定义为(等待时间+服务时间)/服务时间。
当一个进程等待的时间越长,它的响应比越高,优先级越高。
最高响应比优先调度算法会选择具有最高响应比的进程来执行。
如果两个进程的响应比相同,则按照先来先服务的原则进行选择。
当一个进程到达后,它将被插入到就绪队列中,并根据响应比进行排序。
最高响应比优先调度算法的优点是可以避免长时间运行的进程造成其他进程的饥饿现象,提高了系统的响应性。
然而,它的实现相对复杂,需要计算每个进程的响应比。
下面是两种调度算法的模拟设计:先来先服务调度模拟设计:1.定义一个就绪队列,用来保存到达的进程。
2.当一个新的进程到达时,将其加入到就绪队列的末尾。
3.当前运行的进程执行完毕后,从就绪队列中选择队列的第一个进程来执行。
4.执行进程,更新进程的状态和执行时间,直到所有进程执行完毕。
最高响应比优先调度模拟设计:1.定义一个就绪队列,用来保存到达的进程。
2.当一个新的进程到达时,将其加入到就绪队列中,并计算每个进程的响应比。
先来先服务和短作业优先调度算法
先来先服务调度算法和短作业优先调度算法
作业
提交 时间
运行 时间
开始 时间
1 8.00 2.00 8.00
1 8.00 2.00 8.00
2 8.50 0.50 10.00
2 8.50 0.50 10.30
3 9.00 0.10 10.50
3 9.00 0.10 10.00
4 9.50 0.20 10.60
可有效降低作业/进程的平均等待时间。 4
SJ(P)F缺点:
(1) 该算法对长作业不利,如作业C的周转时间由10增 至16,其带权周转时间由2增至3.1。更严重的是,如果有 一长作业(进程)进入系统的后备队列(就绪队列),由于调度 程序总是优先调度那些(即使是后进来的)短作业(进程),将 导致长作业(进程)长期不被调度。(不利长作业)
(2) 该算法完全未考虑作业的紧迫程度,因而不能保证 紧迫性作业(进程)会被及时处理。(不及时)
(3) 由于作业(进程)的长短只是根据用户所提供的估计 执行时间而定的,而用户又可能会有意或无意地缩短其作 业的估计运行时间,致使该算法不一定能真正做到短作业 优先调度。(不完全可靠)
5
调度算法练习题
6
4 9.50 0.20 10.10
先来先服务调度算法
平均周转时间
t = 1.725
平均带权周转时间 w = 6.875
完成 周转 带权周转 执行 时间 时间 时间 顺序
10.00 2.00
1
1
10.00 2.00
1
1
10.50 2.00
4
2
10.80 2.30 4.6
4
10.60 1.60 16
3
10.10 1.10 11
进程调度模拟设计——先来先服务优先级法
进程调度模拟设计——先来先服务优先级法首先,我们来介绍先来先服务调度算法。
FCFS调度算法的原则是按照进程到达的先后顺序进行调度,即先到先执行。
具体步骤如下:1.首先,将所有等待执行的进程按照到达的时间进行排序,即按照先后顺序排列进程队列。
2.选择队列中的第一个进程执行,其余的进程处于等待状态。
3.当当前进程执行完毕或者发生阻塞时,调度器从进程队列中选择下一个进程执行。
4.重复以上步骤,直到所有进程执行完毕。
虽然FCFS调度算法的实现简单,但是存在一个明显的问题,即“饥饿问题”,即如果队列中存在一个长时间执行的进程,其他进程会一直等待,无法得到执行机会。
为了解决饥饿问题,我们引入优先级法调度算法。
优先级法调度算法基于每个进程的优先级来决定调度顺序,具体步骤如下:1.对每个进程设置一个优先级,取值范围从1到n,数值越高表示优先级越高。
2.调度器根据进程的优先级将进程排序,高优先级的进程排在前面。
3.选择优先级最高的进程执行,其余进程处于等待状态。
4.当当前进程执行完毕或者发生阻塞时,调度器从进程队列中选择下一个优先级最高的进程执行。
5.重复以上步骤,直到所有进程执行完毕。
优先级法调度算法解决了饥饿问题,使得所有进程都有机会执行。
然而,优先级法调度算法可能存在一个问题,即“优先级反转问题”。
如果一个低优先级的进程持有一个高优先级的资源,那么其他高优先级的进程就会一直等待,无法得到高优先级资源的使用权。
为了解决优先级反转问题,可以引入优先级继承机制或者抢占式调度策略。
总结起来,先来先服务调度算法按照进程到达的先后顺序进行调度,实现简单但容易导致饥饿问题;优先级法调度算法根据进程的优先级进行调度,避免了饥饿问题但可能导致优先级反转问题。
需要根据不同的应用场景和需求来选择合适的调度算法。
先来先服务FCFS和短作业优先SJF进程调度算法
先来先服务FCFS和短作业优先SJF进程调度算法【实验题目】:先来先服务FCFS和短作业优先SJF进程调度算法通过这次实验,加深对进程概念的理解,进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。
【实验内容】问题描述:设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。
假设有n个进程分别在T1, …,T n时刻到达系统,它们需要的服务时间分别为S1, … ,S n。
分别采用先来先服务FCFS和短作业优先SJF 进程调度算法进行调度,计算每个进程的完成时间,周转时间和带权周转时间,并且统计n个进程的平均周转时间和平均带权周转时间。
【实验要求】要求如下:1)进程个数n;每个进程的到达时间T1, …,T n和服务时间S1, … ,S n;选择算法1-FCFS,2-SJF。
2)要求采用先来先服务FCFS和短作业优先SJF分别调度进程运行,计算每个进程的周转时间,带权周转时间,并且计算所有进程的平均周转时间,带权平均周转时间;3)输出:要求模拟整个调度过程,输出每个时刻的进程运行状态,如“时刻3:进程B开始运行”等等;4)输出:要求输出计算出来的每个进程的周转时间,带权周转时间,所有进程的平均周转时间,带权平均周转时间。
程序代码:#include<iostream.h>#include<iomanip.h>#define Number 5void main(){int n;int daoda[Number],fuwu[Number],i;cout<<"请依次输入各个进程的到达时间并以空格间隔:";for(i=0;i<Number;i++){cin>>daoda[i];}cout<<"请依次输入各个进程的服务时间,并以空格间隔:";for(i=0;i<Number;i++){cin>>fuwu[i];}cout<<"请输入n=1选择FCFS或者n=2选择SJF或者n=3同时调用FCFS 和SJF,n=";cin>>n;while(n<1||n>3){cout<<"输入的n有误,请重新输入n,n=";cin>>n;}struct statedd //声明结构{bool doneF,doneS;int daoda,fuwu;float wancheng,zhouzhuan,daiquan,wan,zhou,dai;};statedd process[Number];//声明结构变量,这里为数组int timeflyF=0,timeflyS=0;//定义两个类似于秒表的变量int j,k,l,nextproF,nextproS;// 获取数据for(i=0;i<Number;i++){process[i].doneF = false;process[i].doneS = false;process[i].wancheng = 0;process[i].zhouzhuan = 0;process[i].daiquan = 0;process[i].wan = 0;process[i].zhou = 0;process[i].dai =0;process[i].daoda = daoda[i];process[i].fuwu = fuwu[i];}// 获取最先到达的进程下标firstint first=0;l=first;for(i=1;i<Number;i++){if(daoda[first]>daoda[i])first=i;}process[first].doneF=true;process[first].doneS=true;process[first].wancheng = process[first].fuwu + process[first].daoda;process[first].wan = process[first].fuwu + process[first].daoda;timeflyF += process[first].daoda+process[first].fuwu;timeflyS += process[first].daoda+process[first].fuwu;// 接下去到达的进程//************************************************************* // fcfs ******************************************************** for(j=1;j<Number;j++){nextproF = Number+1;for(k =0 ; k<Number; k++ ){if( !process[k].doneF ){if( process[k].daoda <= timeflyF ) // 到达{if( nextproF ==Number+1)nextproF = k;else{if( process[nextproF].daoda > process[k].daoda )nextproF = k; //获取到达时刻最先的进程}//else}//if2}//if1}//for// 处理process[nextproF].wancheng = process[nextproF].fuwu + timeflyF;timeflyF += process[nextproF].fuwu;process[nextproF].doneF=true;} // circle2// SJF **********************************************for(j=1;j<Number;j++){nextproS = Number+1;for(k=0 ; k<Number; k++ ){if(!process[k].doneS){if( process[k].daoda <= timeflyS ) // 到达{if( nextproS ==Number+1 )nextproS = k;else{if( process[nextproS].fuwu > process[k].fuwu )nextproS = k; //获取服务时间最小的进程}//else}//if2}//if1}//for// 处理process[nextproS].wan = process[nextproS].fuwu + timeflyS;timeflyS += process[nextproS].fuwu;process[nextproS].doneS=true;} // circle2//**************************************************************** float Fz=0,Fdq=0,Sz=0,Sdq=0;//for(i=0;i<Number;i++){ //----------------------------------------------------process[i].zhouzhuan=process[i].wancheng-process[i].daoda;Fz += process[i].zhouzhuan;process[i].daiquan=process[i].zhouzhuan/process[i].fuwu;Fdq += process[i].daiquan;//----------------------------------------------------process[i].zhou=process[i].wan-process[i].daoda;Sz += process[i].zhou;process[i].dai=process[i].zhou/process[i].fuwu;Sdq += process[i].dai;}//=========================输出==================================//-------------------------------------------------------------------if(n==1||n==3){cout<<"\t"<<endl;cout<<"FCFS:"<<endl;for(i=0;i<Number;i++){if(i<1){cout<<"时刻"<<l<<":进程"<<i+1<<"在运行"<<endl;}else{cout<<"时刻"<<process[i-1].wancheng<<":进程"<<i+1<<"在运行"<<endl;}}cout<<setw(10)<<"进程ID"<<" ";cout<<setw(10)<<"完成时间"<<" ";cout<<setw(10)<<"周转时间"<<" ";cout<<setw(10)<<"带权周转时间"<<" "<<endl;for(i=0;i<Number;i++){cout<<setw(10)<<i+1<<" ";cout<<setw(10)<<setiosflags(ios::fixed)<<setprecision(2)<<process[i].wanc heng<<" ";cout<<setw(10)<<setiosflags(ios::fixed)<<setprecision(2)<<process[i].zhouz huan<<" ";cout<<setw(10)<<setiosflags(ios::fixed)<<setprecision(2)<<process[i].daiqu an<<" "<<endl;}cout<<"平均周转时间为:"<<setiosflags(ios::fixed)<<setprecision(2)<<Fz/Number<<endl;cout<<"平均带权周转时间为:"<<setiosflags(ios::fixed)<<setprecision(2)<<Fdq/Number<<endl;}//-------------------------------------------------------------------if(n==2||n==3){cout<<"\t"<<endl;cout<<"SJF:"<<endl;for(i=0;i<Number;i++){if(i<1){cout<<"时刻"<<l<<":进程"<<i+1<<"在运行"<<endl;}else{cout<<"时刻"<<process[i-1].wan<<":进程"<<i+1<<"在运行"<<endl;}}cout<<setw(10)<<"进程ID"<<" ";cout<<setw(10)<<"完成时间"<<" ";cout<<setw(10)<<"周转时间"<<" ";cout<<setw(10)<<"带权周转时间"<<" "<<endl;for(i=0;i<Number;i++){cout<<setw(10)<<i+1<<" ";cout<<setw(10)<<setiosflags(ios::fixed)<<setprecision(2)<<process[i].wan< <" ";cout<<setw(10)<<setiosflags(ios::fixed)<<setprecision(2)<<process[i].zhou< <" ";cout<<setw(10)<<setiosflags(ios::fixed)<<setprecision(2)<<process[i].dai<< " "<<endl;}cout<<"平均周转时间为:"<<setiosflags(ios::fixed)<<setprecision(2)<<Sz/Number<<endl;cout<<"平均带权周转时间为:"<<setiosflags(ios::fixed)<<setprecision(2)<<Sdq/Number<<endl;cout<<"\t"<<endl;}}实例截图:五个进程,到达时间分别为0,1,3,4,6服务时间分别为5,7,3,8,2设置选择量n,当n=1时,选择FCFS当n=2时,选择SJF当n=3时,同时分别调用FCFS和SJFn不为1或2或3时提示错误,重新输入n;1-FCFS 算法2-SJF算法3同时调用FCFS和SJF。
5种进程调度算法
5种进程调度算法进程调度算法是操作系统中的重要组成部分,用于确定哪个进程将获得CPU的使用权。
根据不同的算法,进程可以以不同的顺序运行,并根据优先级、运行时间、等待时间等因素进行调度。
本文将介绍和分析五种常见的进程调度算法,包括先来先服务(FCFS)、最短作业优先(SJF)、高响应比优先(HRRN)、轮转调度(RR)和多级反馈队列调度(MFQ)。
1.先来先服务(FCFS)先来先服务是最简单的进程调度算法,按照进程到达的顺序分配CPU片段。
当一个进程执行完成或者遇到I/O请求时,CPU被分配给下一个进程。
该算法简单直观,但可能导致长作业等待时间增加,且无法满足实时性要求。
2.最短作业优先(SJF)最短作业优先调度算法根据预计的执行时间为进程分配CPU时间。
在所有就绪队列中,选择执行时间最短的进程。
该算法可以最大程度地减少平均等待时间,但需要准确预测进程的执行时间,而实际中很难精确估计。
3.高响应比优先(HRRN)高响应比优先是一个动态优先级调度算法,根据进程等待时间的长度为进程分配CPU时间。
等待时间越长,优先级越高。
因此,较长等待的进程将获得更多的处理时间,以保证公平性。
该算法在处理短作业时效果较好,但容易导致无限等待。
4.轮转调度(RR)轮转调度算法按照轮询的方式为每个进程分配固定的时间片,通常为几十毫秒。
当时间片用尽时,进程将被暂停,下一个进程得到时间片。
该方法保证了公平性,但对于长时间的进程,可能会浪费大量的CPU时间在进程切换上。
5.多级反馈队列调度(MFQ)多级反馈队列调度算法将进程划分为多个队列,根据进程特性和优先级的不同,为每个队列分配不同的时间片或优先级。
当进程进入就绪队列时,首先进入最高优先级的队列,若运行时间超过时间片,则移入下一级队列。
该算法综合了前几种算法的优点,可以同时满足长短作业的需求。
通过对这五种进程调度算法的介绍和分析,我们可以看到每种算法都有其优点和缺点。
选择适合的进程调度算法取决于系统的需求和特定场景的要求。
先来先服务和短作业优先调度算法
先来先服务和短作业优先调度算法在先来先服务调度算法中,操作系统先根据作业的提交顺序将作业按顺序放入就绪队列中,然后按队列的顺序依次执行作业。
当一个作业执行完成后,下一个作业才会开始执行。
优点:1.简单易实现:先来先服务调度算法的实现非常简单,只需按照作业到达的顺序进行调度即可。
2.公平性:先来先服务调度算法保证了作业的公平性,因为作业的执行顺序完全按照作业到达的顺序进行。
3.低开销:先来先服务调度算法没有额外的开销,只需进行简单的作业切换即可。
缺点:1.平均等待时间长:如果一个长作业先到达,那么后面的短作业就不得不等待较长的时间,导致平均等待时间较长。
2.未能充分利用资源:由于先来先服务调度算法没有对作业的执行时间进行优化,可能导致资源利用率较低,造成浪费。
短作业优先调度算法(Shortest Job First SJF)短作业优先调度算法是根据作业的执行时间来进行调度的。
它的原理是选择执行时间最短的作业优先执行,以此来减少作业的等待时间和周转时间。
在短作业优先调度算法中,操作系统会根据作业的执行时间将作业按照升序排序,然后按照顺序执行作业。
如果有多个作业的执行时间相同,那么可以按照先来先服务的原则进行调度。
优点:1.最小化平均等待时间:短作业优先调度算法根据作业的执行时间来进行调度,能够尽量减少作业的等待时间和周转时间,从而最小化平均等待时间。
2.高资源利用率:由于选择执行时间最短的作业优先执行,能够更加有效地利用系统资源。
缺点:1.难以预测执行时间:在实际情况下,很难准确地预测作业的执行时间,可能导致短作业优先调度算法的准确性下降。
2.可能导致长作业饥饿:如果有长作业在短作业优先调度算法中不断到达,那么短作业可能会一直被优先执行,从而造成长作业饥饿的问题。
总结:先来先服务调度算法和短作业优先调度算法都是常见的调度算法之一,各有其优缺点。
先来先服务调度算法简单易实现,但可能导致平均等待时间长;短作业优先调度算法能够最小化平均等待时间和提高资源利用率,但难以准确预测执行时间可能导致长作业饥饿的问题。
操作系统中常用的进程调度算法
操作系统中常用的进程调度算法1、先来先服务调度算法先来先服务(FCFS)调度算法是一种最简单的调度算法,该算法既可用于作业调度,也可用于进程调度。
当在作业调度中采用该算法时,每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业,将它们调入内存,为它们分配资源、创建进程,然后放入就绪队列。
在进程调度中采用FCFS算法时,则每次调度是从就绪队列中选择一个最先进入该队列的进程,为之分配处理机,使之投入运行。
该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。
2、短作业(进程)优先调度算法短作业(进程)优先调度算法,是指对短作业或短进程优先调度的算法。
它们可以分别用于作业调度和进程调度。
短作业优先(SJF)的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业,将它们调入内存运行。
而短进程优先(SPF)调度算法则是从就绪队列中选出一个估计运行时间最短的进程,将处理机分配给它,使它立即执行并一直执行到完成,或发生某事件而被阻塞放弃处理机时再重新调度。
3、时间片轮转法在早期的时间片轮转法中,系统将所有的就绪进程按先来先服务的原则排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片。
时间片的大小从几ms到几百ms。
当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片。
这样就可以保证就绪队列中的所有进程在一给定的时间内均能获得一时间片的处理机执行时间。
换言之,系统能在给定的时间内响应所有用户的请求。
4、多级反馈队列调度算法前面介绍的各种用作进程调度的算法都有一定的局限性。
如短进程优先的调度算法,仅照顾了短进程而忽略了长进程,而且如果并未指明进程的长度,则短进程优先和基于进程长度的抢占式调度算法都将无法使用。
而多级反馈队列调度算法则不必事先知道各种进程所需的执行时间,而且还可以满足各种类型进程的需要,因而它是目前被公认的一种较好的进程调度算法。
先来先服务调度算法和短作业优先调度算法
先来先服务调度算法和短作业优先调度算法先来先服务调度算法是一种简单的调度策略,即按照进程到达时间的顺序来分配CPU时间片。
当一个进程到达CPU时间的时候,它会被加入到就绪队列中,并在队列中等待调度。
当一个进程完成执行或者发生I/O等等中断时,会使得另一个就绪队列中最前面的进程进入执行状态。
FCFS 的核心思想是谁先到谁先服务,且进程的执行顺序是固定的。
FCFS调度算法的优点是简单直观,易于实现。
在短期调度中,它能够保证不会产生饥饿现象,即保证每个进程都有机会执行。
这使得FCFS 成为一种公平的调度算法。
此外,由于该算法不需要频繁的上下文切换,它在处理长作业的性能上会比其他算法高。
然而,先来先服务调度算法也存在一些缺点。
最主要的问题是平均等待时间较长。
由于所有进程都需要按照到达时间顺序执行,如果前面存在一个执行时间较长的进程,那么后面的进程都需要等待很久才能执行。
这会导致平均等待时间增加,系统的响应时间变慢。
此外,FCFS算法无法适应实时环境,即使有一个紧急的进程,也要等待前面的进程执行完成才能运行。
为了解决FCFS调度算法的平均等待时间较长的问题,短作业优先调度算法应运而生。
短作业优先调度算法是根据进程的执行时间进行排序,选择执行时间最短的进程先执行。
该算法的核心思想是尽量选择执行时间短的进程,以减少平均等待时间。
短作业优先调度算法的优点是能够最大程度地减少平均等待时间,提高系统的响应性能。
由于执行时间短的进程能够快速完成,其他进程就能更快地得到执行。
这种调度算法适用于多任务操作系统,在系统内同时存在多个进程的情况下能够提高系统效率。
此外,SJF算法也可以应用于实时系统,并能够满足紧急任务的需求。
然而,短作业优先调度算法也存在一些问题。
首先,该算法需要准确地预测每个进程的执行时间,否则可能会导致执行时间较长的进程一直等待。
其次,该算法可能产生饥饿现象,即执行时间长的进程可能会一直等待执行。
这是因为短作业优先调度算法会优先选择执行时间短的进程,导致执行时间长的进程无法得到及时执行。
先来先服务FCFS和短作业优先SJF进程调度算法_实验报告材料
先来先服务FCFS和短作业优先SJF进程调度算法_实验报告材料一、实验目的本实验的目的是通过编写程序模拟先来先服务(FCFS)和短作业优先(SJF)进程调度算法,并对其效果进行评估,从而对两种算法有一个更直观的认识。
二、实验原理2. 短作业优先(Shortest-Job-First, SJF)进程调度算法:根据进程的执行时间进行调度,选择执行时间最短的进程先执行。
三、实验步骤1. 设计进程类Process,包含进程名称、到达时间、执行时间等属性,并重载比较运算符以便后续排序。
2. 设计FCFS调度算法函数fcfs_scheduling,实现进程按照先来先服务的规则进行调度。
3. 设计SJF调度算法函数sjf_scheduling,实现进程按照执行时间最短的规则进行调度。
4. 编写主函数,分别调用fcfs_scheduling和sjf_scheduling函数,并根据实际情况输出结果,比较两种算法的效果。
四、实验结果与分析1.输入样例:进程A:到达时间0,执行时间3进程B:到达时间1,执行时间4进程C:到达时间2,执行时间2进程D:到达时间4,执行时间12.输出结果:FCFS调度结果:A->B->C->D,平均等待时间为(0+3+7+9)/4=4.75SJF调度结果:A->C->B->D,平均等待时间为(0+1+3+6)/4=2.53.结果分析:从结果可以看出,短作业优先(SJF)进程调度算法能够更好地减少进程的等待时间,因为它根据进程的执行时间进行调度,优先执行执行时间较短的进程。
与之相比,先来先服务(FCFS)进程调度算法无法对不同进程的执行时间进行判断,可能导致执行时间较短的进程等待时间长。
五、实验总结通过本次实验,我对先来先服务(FCFS)和短作业优先(SJF)进程调度算法有了更深入的了解。
先来先服务(FCFS)算法简单直观,但无法保证最优解;短作业优先(SJF)算法可以减少进程的等待时间,但需要预知每个进程的执行时间。
操作系统实验_先来先服务的调度算法和短作业优先
操作系统实验_先来先服务的调度算法和短作业优先操作系统中的进程调度算法是实现多道程序设计的关键,作为操作系统中的调度器,它决定了进程在CPU上执行的顺序,直接影响到系统的性能和响应时间。
本文将重点介绍两种常用的进程调度算法:先来先服务调度算法(FCFS)和短作业优先调度算法(SJF)。
先来先服务调度算法是一种最简单、最基础的调度算法,其实现非常简单:按照进程到达CPU的先后顺序,将其依次调入CPU执行。
当一个进程进入就绪队列后,在CPU空闲的时候,就将其调入CPU执行,直到进程执行完成或者主动放弃CPU时间片。
这种调度算法的优势在于实现简单、公平性好;但其缺点也很明显,由于没有考虑进程的执行时间长短,如果一个长时间的进程先到达就绪队列,则会造成其他进程的等待时间过长,导致系统的响应时间较长。
与FCFS相对的是短作业优先调度算法(Shortest Job First, SJF)。
SJF调度算法会根据进程的相对执行时间长短来进行调度,即将执行时间最短的进程优先调度进入CPU执行。
SJF算法的关键在于如何估计进程的执行时间,通常有两种方法:预测和历史信息。
预测方法是根据进程的相关信息,如进程的大小、执行时间等进行预测;而历史信息方法是根据以往同类任务的执行时间的平均值或历史执行时间进行估算。
在实际操作中,通常采用后者进行调度。
SJF调度算法的优势在于可以最大程度地减少平均等待时间,提高系统的响应效率。
然而,该算法也存在一些问题,如如何准确估算进程的执行时间、对长时间任务不够友好等。
两种调度算法各自都有其优势和劣势,因此在实际操作中需要根据具体的情况选择适用的调度算法。
如果系统中存在大量长时间任务,可以考虑使用FCFS来保证公平性;而如果系统中的任务短且繁琐,可以优先考虑SJF算法来减少平均等待时间。
此外,还有一些改进版的调度算法,如最短剩余时间优先调度算法(Shortest Remaining Time First, SRTF)和多级反馈队列调度算法(Multi-Level Feedback Queue, MLFQ)等,它们在一定程度上兼顾了FCFS和SJF的优势,更适用于实际的操作系统。
操作系统(先来先服务 短作业优先)进程调度算法模拟程序设计
《操作系统》课程综合性实验指导单适用专业:计算机科学与技术一、实验题目:进程调度算法模拟程序设计二、实验目的:通过对进程调度算法的模拟,进一步理解进程的基本概念,加深对进程运行状态和进程调度过程、调度算法的理解。
三、实验设备及环境:1. 硬件设备:PC机一台2. 软件环境:安装Windows操作系统或者Linux操作系统,并安装相关的程序开发环境,如C \C++\Java 等编程语言环境。
四、实验内容及要求:(1)用C语言(或其它语言,如Java)编程实现对N个进程采用某种进程调度算法(如动态优先权调度算法、先来先服务算法、短进程优先算法、时间片轮转调度算法)调度执行的模拟。
(2)每个用来标识进程的进程控制块PCB可用结构来描述,包括以下字段:✧进程标识数ID。
✧进程优先数PRIORITY,并规定优先数越大的进程,其优先权越高。
✧进程已占用CPU时间CPUTIME。
✧进程还需占用的CPU时间ALLTIME。
当进程运行完毕时,ALLTIME变为0。
✧进程的阻塞时间STARTBLOCK,表示当进程再运行STARTBLOCK个时间片后,进程将进入阻塞状态。
✧进程被阻塞的时间BLOCKTIME,表示已阻塞的进程再等待BLOCKTIME个时间片后,将转换成就绪状态。
✧进程状态STATE。
✧队列指针NEXT,用来将PCB排成队列。
(3)优先数改变的原则:✧进程在就绪队列中呆一个时间片,优先数增加1。
✧进程每运行一个时间片,优先数减3。
(4)为了清楚地观察每个进程的调度过程,程序应将每个时间片内的进程的情况显示出来,包括正在运行的进程,处于就绪队列中的进程和处于阻塞队列中的进程。
(5)分析程序运行的结果,谈一下自己的认识。
五、考核标准:优秀:能很直观方便地定义各个进程,采用一种算法模拟进程调度的过程,算法思想正确;程序设计结构清晰明了;语法、语义正确;实验结果正确;界面美观,布局合理;报告规范,解析完整,文字流畅,题解正确。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
学号:0120910340704操作系统课程设计题目进程调度模拟设计——先来先服务、强占式短进程优先算法学院计算机科学与技术专业计算机科学与技术班级姓名指导教师罗芳2012 年 1 月10 日课程设计任务书学生姓名:专业班级:指导教师:罗芳工作单位:计算机科学与技术学院题目: 进程调度模拟设计——先来先服务、强占式短进程优先算法初始条件:1.预备内容:阅读操作系统的处理机管理章节内容,对进程调度的功能以及进程调度算法有深入的理解。
2.实践准备:掌握一种计算机高级语言的使用。
要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要求)1.模拟进程调度,能够处理以下的情形:⑴能够选择不同的调度算法(要求中给出的调度算法);⑵能够输入进程的基本信息,如进程名、到达时间和运行时间等;⑶根据选择的调度算法显示进程调度队列;⑷根据选择的调度算法计算平均周转时间和平均带权周转时间。
2.设计报告内容应说明:⑴需求分析;⑵功能设计(数据结构及模块说明);⑶开发平台及源程序的主要部分;⑷测试用例,运行结果与运行情况分析;⑸自我评价与总结:i)你认为你完成的设计哪些地方做得比较好或比较出色;ii)什么地方做得不太好,以后如何改正;iii)从本设计得到的收获(在编写,调试,执行过程中的经验和教训);iv)完成本题是否有其他方法(如果有,简要说明该方法);v)对实验题的评价和改进意见,请你推荐设计题目。
时间安排:设计安排一周:周1、周2:完成程序分析及设计。
周2、周3:完成程序调试及测试。
周4、周5:验收、撰写课程设计报告。
(注意事项:严禁抄袭,一旦发现,一律按0分记)指导教师签名:年月日系主任(或责任教师)签名:年月日课程设计报告书1.课程设计的题目进程调度模拟设计——先来先服务、强占式短进程优先算法。
2.课程设计的目的此次课程设计的预备内容是阅读操作系统的处理机管理章节内容,并对进程调度的功能以及进程调度算法有深入的理解和掌握。
完成此次模拟进程调度,需要处理一下的情形:(1)能够选择不同的调度算法(先来先服务算法和强占式短进程优先算法);(2)能够输入进程的基本信息(如进程名、到达时间和运行时间等);(3)根据选择的调度算法显示进程调度队列;(4)根据选择的调度算法计算平均周转时间和平均带权周转时间。
3.需求分析进程调度模拟设计是本次课设的课题,根据其课程设计的目的和要求,对其需求分析如下所示:3.1 对进程信息的描述和实现此次课程设计中,进程作为基本数据处理单元,需要对进程的基本信息进行相关的描述。
进程的基本信息包括进程进程名,到达的时间以及预计的进程运行时间。
设计一个模块,用以实现进程的基本信息的定义和封装,提高设计的简洁性,如使用类模块。
3.2 对调度算法的描述和实现进程基本信息所构成的模块作为基本单元,并且相关调度算法的侧重进程基本信息点不同,所以要根据其调度算法的特点来结合基本信息进行对应的设计。
此次课程设计要求的调度算法描述如下:3.2.1 先来先服务调度算法先来先服务调度算法是以进程的到达时间为判断标准,按各个进程所的到达时间先后顺序进行调度。
要实现此先来先服务调度算法以及考虑程序的简洁性,用一个数据结构如优先级队列,容器等来存储进程基本信息,并要对所有的进程按其到达时间先后顺序进行排序,实现依次取出的进程是所有未运行进程中到达时间最早的进程。
3.2.2 强占式短进程优先调度算法此调度算法和先来先服务调度算法相区别,强占式短进程优先调度算法的实现相对而言较为复杂。
对强占式短进程优先调度算法而言,其本质特征便是按进程的预计运行时间长短进行排序,先执行短进程。
若内存中运行的进程优先级比就绪队列中的某进程优先级低(即运行的进程预计运行时间比就绪队列中的某进程长),此运行的进程让出内存并进入就绪队列,优先级更高的短进程强占内存资源并运行直到结束或者遇到优先级更高的进程强占为止。
3.3计算平均周转时间和平均带权周转时间平均周转时间和平均带权周转时间是对调度算法进行评估的参考标准,在此次课设中要求计算出平均周转时间和平均带钱周转时间。
平均周转时间可由所有进程的周转时间之和除以进程数,同理平均带权周转时间也可如此求得。
3.4 显示调度序列按课程设计要求,要显示进程调度队列,并且还要求对平均周转时间和平均带权周转时间进行显示。
就先来先服务调度算法而言,要求显示的进程调度队列即是进程运行顺序(也就是进程到达时间先后顺序排序的队列);而强占式短进程优先级调度算法中,为了简洁便利的因素以及直观性,所以就以进程完成运行的先后时间顺序进行显示。
4.功能设计此次课设采用面向对象的方法进行对此进程调度系统的模拟。
以下分别就概要设计和详细设计先后进行功能设计的相关描述。
4.1 概要设计此次程序从大的方面来说是利用链表来实现的,在程序中定义了一个结构体struct PCB用来保存没一条记录,每个结点包括进程名、进程的到达时间、预计运行时间、开始运行时间、结束时间、运行次数、仍需运行时间、周转时间、带权周转时间和指向下一个结点的指针。
因为在强占式短进程优先算法中,有的进程要运行一次甚至一次以上,所以定义了进程运行次数和人需运行时间,另外此程序中的所有时间均为整型。
然后定义了几个函数分别用来实现两种算法,首先要做的工作是将输入的所有进程按到达时间的先后顺序排名,这样在先来先服务算法中,他们的顺序便是进程调度顺序,然后在计算出他们的开始时间、结束时间、周转时间等,这些都是小问题不再具体阐述。
强占式短进程优先算法比较复杂,主要的思想是先将第一个到达进程投入运行,等再有进程到达时需将他们的所需运行时间进行比较,将运行时间短的一个投入运行,等再有进程到达时也是利用这种方法决定要运行的进程,这就是强占式短进程优先算法。
实现这个算法时需要的工作有察看在time之前到达但未移动到运行队列的进程数量,在头节点后的count个节点中选择需时间最小的返回。
这是两个重要的工作。
4.2 详细设计界面设计不是本次课程设计的要求,所以就使用dos命令窗口。
而进程调度算法则是本次设计的核心部分,所以就此调度算法部分的逻辑进行阐释说明,进程调度算法的逻辑图如下所示:4.2.1 main函数以及进程信息的输入开始运行主函数输出选择进程调度算法的提示信息输入数据满足要求根据满足要求的输入,调用dispatch的构造函数构生成相应的dispatch对象从文本文档lin.txt读入进程关闭lin/.txt文档调用进程调度算法调用显示进程调度信息的算法print()用delete语句撤销dispatch对象结束主函数的运行是否图14.2.2 先来先服务进程调度算法(FCFS)调用FCFSS算法按到达时间顺序排列的PQueue进程队列是否为空?否取出第PQueue中的队首元素,即PQueue队列中到达时间最早的进程察看当前进程是否访问过?输出错误提示否模拟运行该进程,对总周转时间,总带权周转时间进行赋值,对end_time(结束时间)点赋值。
并把当前进程插入Queue队列,并删除其在PQueue中的信息队列PQueue是否为空?是结束FCFS函数调用图24.2.3 强占式短进程优先进程调度算法(SF )图3调用SF 算法PQueue 队列是空?否取PQueue 队列第一个元素,即到达时间最早的进程进行模拟运行,并计算出不被强占情况下的结束时间点(atime ) 在atime 之前是否有进程到达?是计算出当前系统时间点,并对运行中的进程进行的预计运行时间进行设置(此处以未标志bvisited 时的end_time 表示)。
并将此进程和所有其他新到达进程都插入vector 之中进行排序(排序按预计运行时间短在前长居后),删除新到达的进程在PQeuee 队列中的信息取出vector 中的第一个元素进入模拟运行状态。
否模拟当前进程运行结束,对总周转时间,总带权周转时间,以及运行结束时间点(end_time )赋值。
并把进程信息插入Queue 队列,且删除其在vector 中的进程信息取下一个运行进程的信息V ector 是否为空?否取vector 第一个元素模拟运行是PQueue 队列为空?否 取PQueue 队列的队首元素计算出此进程不被强占情况下的结束时间点是结束SF 函数调用是5 开发平台和源程序主要代码5.1 开发平台本次课程设计编程部分采用Microsoft Visual Studio 2010.5.2 核心代码5.2.1 模块说明Struct PCB定义如下:struct PCB{string name;//进程名int ta;//进程到达时间int ts;//进程估计运行的时间int tb;//进程开始运行时间int tm;//进程仍需运行的时间int to;//进程完成的时间int rn;//进程运行的次数int totalTime;//周转时间double weightTotalTime;//带权周转时间(周转时间/估计运行时间)PCB *next;//定义指向下一个进程的指针};此次程序中定义的函数及其作用如下:PCB *create(PCB *head);//创建进程队列void deal(PCB *head);//FCFS记录处理void sort(PCB *head);//将进程按到达的先后顺序排列int getCount(PCB *head,int time);//察看在time之前到达但未移动到运行队列的进程数量void del(PCB *p);//删除p的下一个节点void fcfsrun(PCB *head);//先来先服务算法PCB *SJF(PCB *head,int count);//在头节点后的count个节点中选择需时间最小的返回void SJFrun(PCB *head);//强占式短进程优先算法另外还定义了三个变量:int pronum;//定义进程数为pronumint total;//记录所有进程的总时间double weight;//记录所有进程的带权周转时间total和weight将用来计算平均周转时间和平均带权周转时间5.2.2 先来先服务(FCFS部分函数)(1)先来先服务的时间处理函数,代码如下:void deal(PCB *head)//FCFS记录处理{sort(head);PCB *p,*q;q=head->next;q->tb=q->ta;q->to=q->tb+q->ts;q->totalTime=q->to-q->ta;q->weightTotalTime=q->totalTime/(double)q->ts;total+=q->totalTime;weight+=q->weightTotalTime;p=q->next;while(p!=NULL){p->tb=q->to;p->to=p->tb+p->ts;p->totalTime=p->to-p->ta;p->weightTotalTime=p->totalTime/(double)p->ts;total+=p->totalTime;weight+=p->weightTotalTime;q=p;p=p->next;}}这段程序将先来先服务算法中的进程开始运行时间,结束时间,周转时间和带权周转时间计算了出了,而且也计算出了平均周转时间。