各类作业调度算法
用于作业调度的算法
用于作业调度的算法作业调度是计算机操作系统中的一个重要概念,它指的是在多个进程同时运行时,如何合理地分配CPU资源,使得系统能够高效地完成各项任务。
作业调度算法是实现作业调度的关键,下面将详细介绍几种常见的作业调度算法。
一、先来先服务(FCFS)算法先来先服务(FCFS)算法是最简单也是最容易实现的一种作业调度算法。
该算法按照进程到达时间的顺序依次执行,即当一个进程到达后,如果当前没有正在执行的进程,则立即执行该进程;否则将该进程加入等待队列中,并等待前面所有进程执行完毕后再进行处理。
FCFS算法优点在于简单易实现,并且保证了公平性。
但由于没有考虑到不同进程的优先级和执行时间等因素,因此可能会导致长任务等待时间过长、短任务响应时间过长等问题。
二、短作业优先(SJF)算法短作业优先(SJF)算法是一种根据作业长度进行排序的调度策略。
该算法按照各个进程需要占用CPU时间片长度进行排序后依次执行,即当一个新的进程到达时,如果其需要占用的时间片长度比当前正在执行的进程短,则立即切换到该进程进行处理,否则将该进程加入等待队列中,并等待前面所有进程执行完毕后再进行处理。
SJF算法优点在于能够最大限度地缩短作业响应时间,提高系统的吞吐量。
但由于需要预测每个进程需要占用的时间片长度,因此实现起来较为困难,并且可能会出现“饥饿”现象,即长时间等待CPU资源的进程无法得到及时处理。
三、优先级调度算法优先级调度算法是一种按照不同进程的优先级进行排序的调度策略。
该算法将每个进程赋予一个优先级值,根据优先级值高低依次执行,即当一个新的进程到达时,如果其优先级比当前正在执行的进程高,则立即切换到该进程进行处理,否则将该进程加入等待队列中,并等待前面所有优先级更高的进程执行完毕后再进行处理。
优先级调度算法可以根据不同任务类型和紧急性进行灵活调整,并且可以避免长任务等待时间过长、短任务响应时间过长等问题。
但由于可能会出现“饥饿”现象和优先级反转等问题,因此需要进行适当的优化和调整。
常用的调度算法
常用的调度算法调度算法是指操作系统中用于决定进程何时执行、何时暂停等的一种算法。
常用的调度算法包括先来先服务(FCFS)、短作业优先(SJF)、优先级调度、时间片轮转等。
下面将对这些常用的调度算法进行详细介绍。
一、先来先服务(FCFS)先来先服务是最简单的调度算法之一,它按照进程到达的顺序进行调度,即谁先到谁先执行。
这种算法容易实现,但是存在“饥饿”现象,即如果某个进程长时间等待,则其他进程可能会一直占用CPU资源,导致该进程无法得到执行。
因此,在实际应用中,FCFS很少被使用。
二、短作业优先(SJF)短作业优先是一种以作业运行时间为依据的调度算法。
它通过预测每个进程需要运行的时间,并将其按照运行时间从小到大排序,然后依次执行。
这种算法可以最大限度地减少平均等待时间和平均周转时间,并且不会出现“饥饿”现象。
但是,在实际应用中,由于很难准确预测每个进程需要运行的时间,因此SJF也存在缺陷。
如果预测不准确,那么就会出现长作业等待短作业的情况,导致长作业的等待时间变长。
三、优先级调度优先级调度是一种按照进程优先级进行调度的算法。
每个进程都有一个优先级,系统会根据进程的优先级来决定下一个要执行的进程。
通常情况下,优先级越高的进程越有可能得到CPU资源。
但是,如果某个进程的优先级一直比其他进程高,那么其他进程就会一直等待,导致“饥饿”现象。
此外,在实际应用中,由于不同进程之间的优先级差别较大,因此可能会导致低优先级的进程长时间等待。
四、时间片轮转时间片轮转是一种按照时间片进行调度的算法。
它将CPU资源划分成若干个时间片,并将每个时间片分配给一个正在运行或等待运行的进程。
当一个进程用完了它所分配到的时间片后,系统会将其挂起,并将CPU资源分配给下一个等待运行的进程。
这种算法可以避免“饥饿”现象,并且能够保证所有正在运行或等待运行的进程都能够得到CPU资源。
但是,如果时间片太小,会导致进程频繁切换,影响系统性能;如果时间片太大,会导致长作业等待时间变长。
各类作业调度算法
各类作业调度算法作业调度算法是操作系统中的重要概念,用于决定计算机系统中各类作业的执行顺序。
它能够优化系统资源利用,提高作业处理效率和用户体验。
本文将介绍各类常见的作业调度算法。
1.先来先服务(FCFS)先来先服务是最简单、最直观的作业调度算法,按照作业到达的顺序来执行。
即当一个作业进入系统后,它将会被放入作业队列的末尾等待执行。
这种算法的优点是简单易懂,缺点是没有考虑作业的执行时间,可能导致长作业占用系统资源时间过长,等待时间较长。
2.最短作业优先(SJF)最短作业优先算法根据每个作业的执行时间来安排执行顺序,执行时间短的作业优先执行。
该算法能够最大限度地缩短作业的等待时间,提高系统的作业处理效率。
然而,这种算法可能会导致长作业饥饿,即长作业始终无法执行,因为每次都有短作业到达系统。
3.最高响应比优先(HRRN)最高响应比优先算法考虑了作业的等待时间和执行时间,通过响应比来确定作业的执行顺序。
响应比定义为(等待时间+执行时间)/执行时间。
该算法能够综合考虑作业的等待时间和执行时间,避免长作业饥饿问题,提高系统的整体响应性能。
4.时间片轮转(RR)时间片轮转算法将系统的执行时间划分为若干个固定大小的时间片,并按照顺序依次分配给作业执行。
每个作业只能在一个时间片内执行,当时间片用完后,如果作业还没有执行完,就需要重新排队等待执行。
时间片轮转算法能够公平地分配系统资源,降低长作业占用系统资源的情况,但也可能导致较大的上下文切换开销。
5.多级队列调度(MLQ)多级队列调度算法将作业划分成多个队列,每个队列具有不同的优先级。
作业首先进入高优先级队列执行,如果执行完后还未完成,就降低其优先级,放入低优先级队列执行。
这样能够确保高优先级作业得到及时执行,同时避免低优先级作业饥饿。
多级队列调度算法常用于实时系统中。
总结来说,作业调度算法有先来先服务、最短作业优先、最高响应比优先、时间片轮转和多级队列调度等。
不同的算法有不同的特点和适用场景,选取合适的作业调度算法能够优化系统资源利用和提高作业处理效率。
作业调度算法
作业调度算法先来先服务算法是最简单的调度算法之一、它按照作业到达的先后顺序进行调度,即先到达的作业先执行,后到达的作业后执行。
这种算法的优点是实现简单,适用于一些简单的场景。
然而,它的缺点也很明显,即平均等待时间较长,可能会导致长作业时间的作业一直占用CPU,造成资源浪费。
短作业算法是一种基于作业的执行时间长度进行调度的算法。
它会优先执行执行时间最短的作业。
这种算法的优点是能够最大程度地减少平均等待时间,使得短作业能够快速得到执行。
然而,缺点是可能会导致长作业长时间等待,造成长作业的响应时间增长。
这两种算法在不同的场景下有着不同的应用。
先来先服务算法适用于任务到达时间相对较为平均的场景,能够保证公平性,使得每个作业都有机会得到执行。
而短作业算法适用于任务执行时间差距较大的场景,能够尽可能减少平均等待时间,并且能够提升系统的响应速度。
需要注意的是,这两种算法都存在一种问题,即长作业会一直占用CPU,可能造成短作业长时间等待。
为了解决这个问题,可以引入抢占式调度算法,例如短作业剩余时间优先算法(Shortest Remaining Time Next,SRTN)。
SRTN算法在执行过程中会动态地检测作业的执行时间,一旦有更短的作业到达,就会抢占当前的作业,提高了系统的性能。
总的来说,先来先服务算法和短作业算法都是作业调度中常用的算法。
在实际应用中,可以根据具体情况选择合适的算法,或者结合多种算法来获取更好的调度效果。
作业调度算法的选择对于系统的性能和资源利用率具有重要的影响,需要根据实际需求进行综合权衡。
关于作业调度算法
关于作业调度算法作业调度算法是计算机操作系统中的一个重要问题,它涉及到如何合理、高效地安排进程或任务在计算机系统中的执行顺序。
在操作系统中,进程是计算机执行任务的最小单位,作业调度算法的目标就是通过合理地调度进程,使得系统在保证资源利用率的同时,能够满足用户和系统的需求。
作业调度算法的设计与选择,对于计算机系统的性能和用户体验都有着重要的影响。
因此,作业调度算法需要综合考虑多个因素,如响应时间、吞吐量、资源利用率、公平性等。
以下是几种常见的作业调度算法的介绍:2. 短作业优先(Shortest-Job-First, SJF)算法:根据进程估计执行时间的长短进行调度,即优先选择执行时间最短的进程。
这个算法可以最大程度地减少平均等待时间,提高系统的响应速度,但需要预估进程的执行时间,对于预测不准确的情况,可能会导致长作业等待时间过长。
3.优先级调度算法:为每个进程分配一个优先级,根据优先级的高低进行调度。
这个算法可以根据系统和用户的需求,合理地安排进程的执行顺序,但需要考虑如何设置优先级,以及如何防止优先级反转等问题。
4. 时间片轮转(Round Robin, RR)算法:将每个进程分配一个固定的时间片,按照时间片顺序进行调度。
当一个进程的时间片用完后,将被强制切换到下一个进程,从而实现多个进程轮流执行。
这个算法可以实现公平调度,确保每个进程都能得到执行机会,但可能会导致上下文切换的开销过大,影响系统性能。
除了以上介绍的几种算法,还有很多其他的作业调度算法,如最高响应比优先(Highest-Response-Ratio-Next, HRRN)算法、多级反馈队列算法等,每种算法都有自己的优缺点,适用于不同的场景和需求。
在实际应用中,作业调度算法的设计和选择需要根据具体的情况进行评估和优化。
例如,对于高响应速度的实时系统,可能更适合使用短作业优先算法;对于需要兼顾公平性和资源利用率的系统,可能更适合使用多级反馈队列算法。
关于作业调度算法
关于作业调度算法作业调度算法是指在计算机系统中对作业进行合理安排和调度的一种方法。
作业调度算法的目标是优化系统资源的利用,提高作业的响应时间和吞吐量,提高系统的整体性能。
在实际应用中,作业调度算法起着至关重要的作用。
作业调度算法有很多种,每种算法都有其适用的场景和特点。
下面将介绍几种常见的作业调度算法。
1.先来先服务(FCFS)算法:先来先服务算法是通过按照作业到达的顺序进行调度的算法。
简单来说,就是按照作业提交的先后顺序进行调度。
这种算法的特点是简单、公平,但是对于作业的响应时间和系统的吞吐量效果较差。
2.短作业优先(SJF)算法:短作业优先算法是根据作业的执行时间进行调度的算法。
它的原理是,执行时间短的作业能够更快地完成,从而能够提高系统的响应时间和吞吐量。
然而,这种算法容易导致长作业等待时间过长,从而影响长作业的执行效率。
3.最高响应比优先(HRRN)算法:最高响应比优先算法是根据作业的等待时间和执行时间的比值进行调度的算法。
它的原理是,等待时间长的作业和执行时间短的作业都有更高的响应比,因此优先调度等待时间长的作业。
这种算法能够兼顾作业的响应时间和系统的吞吐量。
4.时间片轮转(RR)算法:时间片轮转算法是指将CPU的执行时间分成多个时间片,每个时间片的长度固定,作业按照时间片的顺序进行调度。
当作业的执行时间超过一个时间片时,将被放入一个等待队列,并在下一个时间片重新调度。
这种算法能够保证每个作业都能获得一定的执行时间,但不能很好地兼顾作业的响应时间。
5.最短剩余时间(SRT)算法:最短剩余时间算法是在短作业优先算法的基础上进行优化得到的。
在该算法中,系统会根据当前作业的执行时间和剩余执行时间来选择下一个要执行的作业。
这种算法能够更加准确地估计作业的完成时间,从而提高系统的响应时间和吞吐量。
除了以上几种常见的作业调度算法,还有很多其他的算法可以根据系统的特点和需求进行选择和优化,如最短作业优先(SJN)算法、优先级调度算法、多级反馈队列调度算法等。
操作系统中常用作业调度算法的分析
操作系统中常用作业调度算法的分析作业调度是操作系统中的一个重要组成部分,它负责对待执行的作业进行排队和调度,以最大化系统资源的利用效率、满足用户需求、保证系统稳定性等目标。
常见的作业调度算法有先来先服务(FCFS)、最短作业优先(SJF)、优先级调度、时间片轮转(RR)等,接下来我们分别对这几种算法进行分析。
1. FCFS调度算法先来先服务调度算法是操作系统中最简单的一种调度算法,也是最常用的一种调度算法。
它的处理方式是根据提交时间顺序,按照FIFO的顺序进行调度。
该算法的优点是简单易用,而且很容易实现。
同时,对于大多数情况下,该算法的资源分配相对公平。
但是,该算法存在着一些问题。
当一个作业的执行时间较长时,会大大降低系统的吞吐量,严重影响系统的效率。
因此,在实际应用中,该算法往往不能满足对作业的实时响应和高效完成的要求。
最短作业优先调度算法是一种非抢占式调度算法,它将作业按照其需要执行的时间长短大小进行排序,然后从执行时间最短的作业开始调度。
在实际应用中,该算法可以减少平均等待时间和平均周转时间,提高系统的效率和性能。
但是,该算法有个致命的缺点——它无法预测作业的执行时间。
如果一个长作业被排在了等待队列的前面,那么所有后续的短作业都要等待非常长的时间,这可能导致饥饿现象的出现。
3. 优先级调度算法优先调度算法是一种根据作业优先级大小进行调度的算法,可以根据作业的重要程度或紧急程度来设置不同的优先级。
该算法可以提高系统的响应速度和稳定性,满足系统特定的需求。
但是,该算法也存在着一些问题。
如果一个作业的优先级太高,那么其余的作业可能会一直处于等待状态,这种情况也会导致饥饿现象的出现。
此外,该算法的优先级设置需要有一定的经验和技巧,否则可能会对系统的性能产生不良影响。
4. 时间片轮转算法时间片轮转算法是一种循环调度算法,它将CPU的时间分成多个固定大小的时间片,然后在每个时间片内轮流执行等待队列中的作业,以便平均分配CPU资源。
作业调度算法(先来先服务算法,短作业算法)
题目:作业调度算法班级:网络工程姓名:朱锦涛学号:E一、实验目的用代码实现页面调度算法,即先来先服务(FCFS)调度算法、短作业优先算法、高响应比优先调度算法。
通过代码的具体实现,加深对算法的核心的理解。
二、实验原理1.先来先服务(FCFS)调度算法FCFS是最简单的调度算法,该算法既可用于作业调度,也可用于进程调度。
当在作业调度中采用该算法时,系统将按照作业到达的先后次序来进行调度,或者说它是优先考虑在系统中等待时间最长的作业,而不管该作业所需执行的时间的长短,从后备作业队列中选择几个最先进入该队列的作业,将它们调入内存,为它们分配资源和创建进程。
然后把它放入就绪队列。
2.短作业优先算法SJF算法是以作业的长短来计算优先级,作业越短,其优先级越高。
作业的长短是以作业所要求的运行时间来衡量的。
SJF算法可以分别用于作业和进程调度。
在把短作业优先调度算法用于作业调度时,它将从外存的作业后备队列中选择若干个估计运行时间最短的作业,优先将它们调入内存。
3、高响应比优先调度算法高响应比优先调度算法则是既考虑了作业的等待时间,又考虑了作业的运行时间的算法,因此既照顾了短作业,又不致使长作业等待的时间过长,从而改善了处理机调度的性能。
如果我们引入一个动态优先级,即优先级是可以改变的令它随等待的时间的延长而增加,这将使长作业的优先级在等待期间不断地增加,等到足够的时间后,必然有机会获得处理机。
该优先级的变化规律可以描述为:优先权 = (等待时间 + 要求服务时间)/要求服务时间三、实验内容源程序:#include<>#include<>#include<>struct work{i nt id;i nt arrive_time;i nt work_time;i nt wait;f loat priority;typedef struct sjf_work{s truct work s_work; d = rand()%10;w[i].arrive_time = rand()%10;w[i].work_time = rand()%10+1;}f or(j=0;j<5;j++){printf("第%d个作业的编号是:%d\t",j+1,w[j].id);printf("第%d个作业到达时间:%d\t",j+1,w[j].arrive_time);printf("第%d个作业服务时间:%d\t",j+1,w[j].work_time);printf("\n");for(j=1;j<5;j++)for(k=0;k<5-j;k++){if(w[k].arrive_time > w[k+1].arrive_time) {temp = w[k];w[k] = w[k+1];w[k+1] = temp;}}printf("\n");w_finish_time[0] = w[0].arrive_time +w[0].work_time;for(j=0;j<5;j++){if(w_finish_time[j] < w[j+1].arrive_time){w_finish_time[j+1] = w[j+1].arrive_time + w[j+1].work_time;}elsew_finish_time[j+1] = w_finish_time[j] +w[j+1].work_time;}for(j=0;j<5;j++)w_rel_time[j] = w_finish_time[j] -w[j].arrive_time;for(j=0;j<5;j++){rel_time += w_rel_time[j];}for(j=0;j<5;j++){printf("第%d个系统执行的作业到达时间:%d ",j+1,w[j].arrive_time);printf("编号是:%d ",w[j].id);printf("服务时间是:%d ",w[j].work_time);printf("完成时间是:%d ",w_finish_time[j]);printf("周转时间是:%d ",w_rel_time[j]);printf("\n");}printf("平均周转时间:%f\n",rel_time/5); }void SJF(){i nt w_rel_time[10];i nt w_finish_time[10];f loat rel_time = 0;s rand(time(0));i nt i;i nt j = 0;P NODE pHead = (PNODE)malloc(sizeof(NODE));i f (NULL == pHead){printf("分配失败, 程序终止!\n");exit(-1);P NODE pTail = pHead;p Tail->pNext = NULL; 来先服务算法该算法严格按照各作业到达时间来为其分配进程和资源,实验的结果见截图,最后算出该算法五个作业的平均周转时间。
各类作业调度算法
各类作业调度算法作业调度是计算机系统中的重要问题,涉及到如何合理地分配和调度系统资源,以最大化系统的吞吐量和性能。
针对不同的应用场景和需求,有多种不同的作业调度算法。
本文将介绍几种常见的作业调度算法,包括先来先服务调度算法(FCFS)、最短作业优先调度算法(SJF)、优先级调度算法、轮转调度算法(RR)和最高响应比优先调度算法(HRRN)。
先来先服务调度算法(FCFS)是最简单的一种调度算法。
它按照作业的到达时间顺序为其分配资源,即先来的作业先执行,后来的作业后执行。
这种算法的优点是实现简单,公平性好,但是缺点也很明显,它无法考虑作业的执行时间,如果一个长作业在前面执行,可能会导致后面的短作业等待时间过长,从而影响整个系统的效率。
最短作业优先调度算法(SJF)是一种根据作业执行时间的长短来分配资源的算法。
它会选择剩余执行时间最短的作业来执行,从而最大程度上减少作业的等待时间。
这种算法可以很好地提高系统的性能,但是需要事先知道每个作业的执行时间,而且无法应对作业执行时间波动较大的情况。
优先级调度算法主要根据作业的优先级来决定资源的分配顺序。
每个作业都有一个对应的优先级,具有较高优先级的作业会被优先调度执行。
不同作业的优先级可以通过用户设置或者系统自动派发来确定。
这种算法可以灵活地应对不同的需求,但是需要合理设置优先级,否则可能导致资源被一直分配给优先级较高的作业,而忽略其他作业。
轮转调度算法(RR)是一种按照时间片轮流分配资源的算法。
每个作业都有一个固定的时间片,当一个作业的时间片用完后,就将资源分配给下一个作业。
这种算法可以平衡各个作业的等待时间,对于长作业和短作业都能有一定的公平性,但是如果时间片设置得过长,可能导致系统响应时间较长。
最高响应比优先调度算法(HRRN)是根据作业的响应比来决定资源分配顺序的算法。
响应比由作业的等待时间与执行时间之比计算得出,作业的响应比越高,代表其等待时间相对较长,应该优先进行资源分配。
FCFS,SJF,HRRN算法实现作业调度
FCFS,SJF,HRRN算法实现作业调度实验原理(1)定义程序控制块的结构体和程序⼯作时间的结构体,JCB可以包含以下信息:作业名、提交(到达)时间、所需的运⾏时间、所需的资源、作业状态、链指针等等。
程序⼯作时间包括作业运⾏时刻,作业完成时刻,周转时间,带权周转时间。
(2)主程序默认采⽤的算法是先来先服务,当选择另外两种算法时通过主程序去调⽤这种作业调度算法,分别是SJF,HRN。
(3)通过构造进程输⼊input(),进程运⾏结果输出output(),disp(),以及使整个程序正常运⾏的函数块等,通过主函数调⽤⽅法函数的想法来实现作业调度。
(4)在对程序控制块的访问和调⽤通过链表指针的形式,进⾏调⽤各种作业调度算法。
在作业输⼊后,会显⽰输⼊的内容,并把每⼀个作业运⾏的状态都能在程序中体现出来。
1 #include<stdio.h>2 #include <stdlib.h>3 #include <conio.h>4#define getpch(type) (type*)malloc(sizeof(type)) //为进程创建⼀个空间56struct worktime{7float Tb; //作业运⾏时刻8float Tc; //作业完成时刻9float Ti; //周转时间10float Wi; //带权周转时间11 };1213struct jcb {14char name[10]; //作业名15float arrivetime; //作业到达时间16float runtime; //作业所需的运⾏时间17char resource; //所需资源18float Rp; //后备作业响应⽐19char state; //作业状态20int worked_time; //已运⾏时间21struct worktime wt;22int need_time; //需要运⾏的时间23int flag; //进程结束标志24struct jcb* link; //链指针25 }*ready=NULL,*p;2627 typedef struct jcb JCB;//重命名结构体28float T=0;29int N;30 JCB *front,*rear;3132void sort()33 {34 JCB *first, *second;35int insert=0; //插⼊数36if((ready==NULL)||((p->arrivetime)<(ready->arrivetime)))37 {38 p->link=ready;39 ready=p;40 T=p->arrivetime;41 p->Rp=1;42 }43else44 {45 first=ready;46 second=first->link;47while(second!=NULL)48 {49if((p->arrivetime)<(second->arrivetime))50 {51 p->link=second;52 first->link=p;53 second=NULL;54 insert=1;55 }56else57 {58 first=first->link;59 second=second->link;60 }61 }62if (insert==0) first->link=p;63 }64 }6566void SJFget()67 {68 JCB *front,*mintime,*rear;69int ipmove=0;70 mintime=ready;71 rear=mintime->link;72while(rear!=NULL)73 {74if ((rear!=NULL)&&(T>=rear->arrivetime)&&(mintime->runtime)>(rear->runtime))75 {76 front=mintime;77 mintime=rear;78 rear=rear->link;79 ipmove=1;80 }81else82 rear=rear->link;83 }84if (ipmove==1)85 {86 front->link=mintime->link;87 mintime->link=ready;88 }89 ready=mintime;90 }9192void HRNget()93 {94 JCB *front,*mintime,*rear;95int ipmove=0;96 mintime=ready;97 rear=mintime->link;98while(rear!=NULL)99if ((rear!=NULL)&&(T>=rear->arrivetime)&&(mintime->Rp)<(rear->Rp))100 {101 front=mintime;102 mintime=rear;103 rear=rear->link;104 ipmove=1;105 }106else107 rear=rear->link;108if (ipmove==1){109 front->link=mintime->link;110 mintime->link=ready;111 }112 ready=mintime;113 }114115void creatJCB() //为每个作业创建⼀个JCB并初始化形成⼀个循环链队列116 {117 JCB *p,*l;118int i=0;119 l = (JCB *)malloc(sizeof(JCB));120 printf("\n 请输⼊作业的个数:");121 scanf("%d",&N);122 printf("\n 作业号No.%d:\n",i);123 printf("\n请输⼊作业的名字:");124 scanf("%s",l->name);125 printf("\n请输⼊作业需要运⾏的时间:");126 scanf("%d",&l->need_time);127 l->state = 'r'; //作业初始状态为就绪(即准备状态)128 l->worked_time = 0;129 l->link=NULL;130 l->flag=0;131 front=l;132for(i =1;i<N;i++)133 {134 p = (JCB *)malloc(sizeof(JCB));135 printf("\n 作业号No.%d:\n",i);136 printf("\n请输⼊作业的名字:");137 scanf("%s",p->name);138 printf("\n请输⼊作业的时间:");139 scanf("%d",&p->need_time);140 p->state='r';141 p->worked_time=0;142 p->flag=0;143 l->link=p;144 l=l->link;145 }146 rear=l;rear->link=front;147 }148149void output()//进程输出函数150 {151int j;152 printf("name runtime needtime state\n");153for(j=1;j<=N;j++)154 { printf(" %-4s\t%-4d\t%-4d\t%-c\n",front->name,front->worked_time,front->need_time,front->state);155 front=front->link;156 }157 printf("\n");158 }159160int judge(JCB *p) //判断所有进程运⾏结束161 {162int flag=1,i;163for(i=0;i<N;i++)164 {165if(p->state!='e')166 {167 flag = 0;168break;}169 p=p->link;170 }171return flag;172 }173174//作业输⼊175void input()176 {177int i,num;178 printf("\n 请输⼊作业的个数:");179 scanf("%d",&num);180for(i=0;i<num;i++)181 {182 printf(" 作业号No.%d:\n",i);183 p=getpch(JCB);184 printf(" 输⼊作业名:");185 scanf("%s",p->name);186 printf(" 输⼊作业到达时刻:");187 scanf("%f",&p->arrivetime);188 printf(" 输⼊作业运⾏时间:");189 scanf("%f",&p->runtime);190 printf("\n");191 p->state='w';192 p->link=NULL;193 sort();194 }195 }196197int space()198 {199int l=0; JCB* jr=ready;200while(jr!=NULL)201 {202 l++;203 jr=jr->link;204 }205return(l);206 }207208void disp(JCB* jr,int select)209 {210if (select==3) printf("\n 作业到达时间服务时间响应⽐运⾏时刻完成时刻周转时间带权周转时间 \n"); 211else printf("\n 作业到达时间服务时间运⾏时刻完成时刻周转时间带权周转时间 \n");212 printf(" %s\t",jr->name);213 printf("%.2f\t ",jr->arrivetime);214 printf("%.2f\t",jr->runtime);215if (select==3&&p==jr) printf(" |%.2f ",jr->Rp);216if (p==jr){217 printf(" %.2f\t",jr->wt.Tb);218 printf(" %.2f ",jr->wt.Tc);219 printf(" %.2f\t",jr->wt.Ti);220 printf(" %.2f",jr->wt.Wi);221 }222//printf("\n");223 }224225int destroy()226 {227free(p);228return(1);229 }230231void check(int select)232 {233 JCB* jr;234 printf(" 是 :%s",p->name);//当前执⾏的作业是235 disp(p,select);236 jr=ready;237 destroy();238 }239240void running(JCB* jr)241 {242if (T>=jr->arrivetime) jr->wt.Tb=T;243else jr->wt.Tb=jr->arrivetime;244 jr->wt.Tc=jr->wt.Tb+jr->runtime;245 jr->wt.Ti=jr->wt.Tc-jr->arrivetime;246 jr->wt.Wi=jr->wt.Ti/jr->runtime;247 T=jr->wt.Tc;248 }249250int main()251 {252int select=0,len,h=0;253float sumTi=0,sumWi=0;254 printf("请选择作业调度算法的⽅式:\n");255 printf("\t1.FCFS 2.SJF 3.HRN \n");256 printf("请输⼊作业调度算法序号(1-3):");257 scanf("%d",&select);258259 input(); //调⽤输⼊函数260 len=space();261262263while((len!=0)&&(ready!=NULL))264 {265 h++;266 printf(" 第%d个执⾏作业 ",h);267 p=ready;268 ready=p->link;269 p->link=NULL;270 p->state='R';271 running(p);272 sumTi+=p->wt.Ti;273 sumWi+=p->wt.Wi;274 check(select); //与所选择的算法⽐较,调⽤void check(int select)275if (select==2&&h<len-1) SJFget();276if (select==3&&h<len-1) HRNget();277 getchar();278 getchar();279 }280 printf(" 作业已经完成.\n");281 printf("\t 此组作业的平均周转时间:%.2f\n",sumTi/h);282 printf("\t 此组作业的带权平均周转时间:%.2f\n",sumWi/h);283 getchar();284 }程序运⾏结果 FCFSSJFHRRN总结与体会通过本次实验,感觉⾃⼰对之前数据结构的算法和语法掌握得不是很好,虽然会定义结构体⽐较熟练,但是对于在程序中调⽤结构体就不太理解,导致多次出错,并通过查阅相关资料,然后不断修改,由于之前的数据结构学得不扎实,所以写代码遇到很多困难,往后要多回顾旧知识,特别是语法结构和新接触的⼏种作业调度的算法思想。
作业调度算法(先来先服务算法,短作业算法)
《操作系统》实验报告题目:作业调度算法班级:网络工程姓名:朱锦涛学号:E31314037一、实验目的用代码实现页面调度算法,即先来先服务(FCFS)调度算法、短作业优先算法、高响应比优先调度算法。
通过代码的具体实现,加深对算法的核心的理解。
二、实验原理1.先来先服务(FCFS)调度算法FCFS是最简单的调度算法,该算法既可用于作业调度,也可用于进程调度。
当在作业调度中采用该算法时,系统将按照作业到达的先后次序来进行调度,或者说它是优先考虑在系统中等待时间最长的作业,而不管该作业所需执行的时间的长短,从后备作业队列中选择几个最先进入该队列的作业,将它们调入内存,为它们分配资源和创建进程。
然后把它放入就绪队列。
2.短作业优先算法SJF算法是以作业的长短来计算优先级,作业越短,其优先级越高。
作业的长短是以作业所要求的运行时间来衡量的。
SJF算法可以分别用于作业和进程调度。
在把短作业优先调度算法用于作业调度时,它将从外存的作业后备队列中选择若干个估计运行时间最短的作业,优先将它们调入内存。
3、高响应比优先调度算法高响应比优先调度算法则是既考虑了作业的等待时间,又考虑了作业的运行时间的算法,因此既照顾了短作业,又不致使长作业等待的时间过长,从而改善了处理机调度的性能。
如果我们引入一个动态优先级,即优先级是可以改变的令它随等待的时间的延长而增加,这将使长作业的优先级在等待期间不断地增加,等到足够的时间后,必然有机会获得处理机。
该优先级的变化规律可以描述为:优先权 = (等待时间 + 要求服务时间)/要求服务时间三、实验内容源程序:#include<stdio.h>#include<stdlib.h>#include<time.h>struct work{i nt id;i nt arrive_time;i nt work_time;i nt wait;f loat priority;};typedef struct sjf_work{s truct work s_work; //数据域s truct sjf_work * pNext; //指针域}NODE,*PNODE;void FCFS();void SJF();void showmenu();bool Is_empty(PNODE pHead);int cnt_work(PNODE pHead);PNODE do_work(PNODE pHead,int *w_finish_time,int i);void show(int *w_finish_time,int i,PNODE q,int*w_rel_time);void HRRN();PNODE priorit(PNODE pHead);void do_work_1(PNODE pHead,int *w_finish_time,int i);int main(){i nt choice; //设置选择数s howmenu(); //显示菜单s canf("%d",&choice);w hile(choice != 0) //选择算法{switch(choice){case 1 :printf("您选择的是先来先服务算法:\n");FCFS();break;case 2 :printf("您选择的是短作业优先算法:\n");SJF();break;case 3 :printf("您选择的是高响应比优先调度算法\n");HRRN();break;default:printf("请重新选择!");break;}printf("\n");printf("下面是菜单,请继续,或者按‘0’退出"); showmenu();scanf("%d",&choice);}p rintf("感谢您使用本系统,再见!");r eturn 0;}void FCFS(){i nt j,k;i nt w_rel_time[5];i nt w_finish_time[5];f loat rel_time = 0;struct work temp;i nt i;s truct work w[5];s rand(time(0));f or(i=0;i<5;i++){w[i].id = rand()%10;w[i].arrive_time = rand()%10;w[i].work_time = rand()%10+1;}f or(j=0;j<5;j++){printf("第%d个作业的编号是:%d\t",j+1,w[j].id);printf("第%d个作业到达时间:%d\t",j+1,w[j].arrive_time);printf("第%d个作业服务时间:%d\t",j+1,w[j].work_time);printf("\n");}for(j=1;j<5;j++)for(k=0;k<5-j;k++){if(w[k].arrive_time > w[k+1].arrive_time){temp = w[k];w[k] = w[k+1];w[k+1] = temp;}}printf("\n");w_finish_time[0] = w[0].arrive_time + w[0].work_time;for(j=0;j<5;j++){if(w_finish_time[j] < w[j+1].arrive_time){w_finish_time[j+1] = w[j+1].arrive_time + w[j+1].work_time;}elsew_finish_time[j+1] = w_finish_time[j] +w[j+1].work_time;}for(j=0;j<5;j++)w_rel_time[j] = w_finish_time[j] -w[j].arrive_time;for(j=0;j<5;j++){rel_time += w_rel_time[j];}for(j=0;j<5;j++){printf("第%d个系统执行的作业到达时间:%d ",j+1,w[j].arrive_time);printf("编号是:%d ",w[j].id);printf("服务时间是:%d ",w[j].work_time);printf("完成时间是:%d ",w_finish_time[j]);printf("周转时间是:%d ",w_rel_time[j]);printf("\n");}printf("平均周转时间:%f\n",rel_time/5);}void SJF(){i nt w_rel_time[10];i nt w_finish_time[10];f loat rel_time = 0;s rand(time(0));i nt i;i nt j = 0;P NODE pHead = (PNODE)malloc(sizeof(NODE));i f (NULL == pHead){printf("分配失败, 程序终止!\n");exit(-1);}P NODE pTail = pHead;p Tail->pNext = NULL; //定义该链表有头结点,且第一个节点初始化为空f or(i=0;i<10;i++){PNODE pNew = (PNODE)malloc(sizeof(NODE));if (NULL == pNew){printf("分配失败, 程序终止!\n");exit(-1);}pNew->s_work.id = rand()%100;pNew->s_work.arrive_time = rand()%10;pNew->s_work.work_time = rand()%10+1;pTail->pNext = pNew;pNew->pNext = NULL;pTail = pNew;}P NODE p = pHead->pNext; //p指向第一个节点w hile (NULL != p){printf("第%d个作业的编号是:%d\t",j+1,p->s_work.id);printf("第%d个作业到达时间:%d\t",j+1,p->s_work.arrive_time);printf("第%d个作业服务时间:%d\t",j+1,p->s_work.work_time);printf("\n");p = p->pNext;printf("\n");j++;}p = pHead->pNext;P NODE q = p; //p,q都指向第一个节点p = p->pNext;w hile(p != NULL){if(p->s_work.arrive_time < q->s_work.arrive_time)q = p;p = p->pNext;}P NODE r = pHead->pNext; //r也指向第一个节点i nt cnt = 0; //记录所有节点数据域中到达时间最短且相等的个数w hile(r!= NULL){if( r->s_work.arrive_time == q->s_work.arrive_time ) cnt++;r = r->pNext;}p = pHead->pNext;w hile(p != NULL) //在相等到达时间的作业中找服务时间最短的作业{if(cnt > 1){if( p->s_work.arrive_time ==q->s_work.arrive_time )if( p->s_work.work_time < q->s_work.work_time )q = p;p = p->pNext;}elsep =NULL;} //确定q所指作业最先到达且服务时间最短w_finish_time[0] = q->s_work.arrive_time +q->s_work.work_time;w_rel_time[0] = w_finish_time[0] -q->s_work.arrive_time;p rintf("第1个系统执行的作业到达时间:%d",q->s_work.arrive_time);p rintf("编号是:%d ",q->s_work.id);p rintf("服务时间是:%d \n",q->s_work.work_time); p rintf("完成时间是:%d ",w_finish_time[0]);p rintf("周转时间是:%d \n",w_rel_time[0]);p = pHead; //寻找q的前一个节点,方便删掉q节点w hile( p->pNext != q ){p = p->pNext;}p->pNext = q->pNext;f ree(q);q = NULL;f or(i=0;i<9&&!Is_empty(pHead);i++){printf("现在系统还剩%d个作业!\n",cnt_work(pHead));q = do_work(pHead,w_finish_time,i);show(w_finish_time,i,q,w_rel_time);p = pHead; //寻找q的前一个节点,方便删掉q节点while( p->pNext != q ){p = p->pNext;}p->pNext = q->pNext;free(q);q = NULL;}f or(j=0;j<10;j++)rel_time += w_rel_time[j];}printf("平均周转时间:%f\n",rel_time/10);}bool Is_empty(PNODE pHead) //判断作业是否做完{P NODE p;p = pHead->pNext;i nt len = 0;w hile(p != NULL){len++;p = p->pNext;}i f(len == 0)return true; //当没有作业时,返回为真e lsereturn false;}int cnt_work(PNODE pHead) //计算当前还剩多少作业{P NODE p;p = pHead->pNext;i nt len = 0;w hile(p != NULL){len++;p = p->pNext;}r eturn len;}PNODE do_work(PNODE pHead,int *w_finish_time,int i) {P NODE p,q;i nt cnt = 0; //计数器清0,计算当前作业完成时,系统中有多少个作业已经到达p = pHead->pNext;q = p;w hile(p != NULL){if( p->s_work.arrive_time <= w_finish_time[i] ){cnt ++;q = p;p = p->pNext;}else{p = p->pNext;}} //q指向当前到达时间小于刚刚完成的作业,但不一定是服务时间最短的(如果有的话)p rintf("系统中有%d个作业在当前作业完成时已经到达!\n",cnt);p = pHead->pNext;w hile(p != NULL){if(cnt>1) //执行此次判断后,q现在指向所有条件都满足的作业(如果有的话){if( p->s_work.arrive_time <= w_finish_time[i] ){if( p->s_work.work_time < q->s_work.work_time ){q = p;p = p->pNext;}elsep = p->pNext;}elsep = p->pNext;}else //当前作业完成时,没有作业到达的情况{p = p->pNext; //用q来接收最先到达的,用p来遍历while( p != NULL ){if( p->s_work.arrive_time<q->s_work.arrive_time )q = p;p = p->pNext;}w_finish_time[i+1] = q->s_work.arrive_time + q->s_work.work_time;}}w_finish_time[i+1] = w_finish_time[i] +q->s_work.work_time;r eturn q;}void show(int *w_finish_time,int i,PNODE q,int*w_rel_time){w_finish_time[i+1] = w_finish_time[i] +q->s_work.work_time;w_rel_time[i+1] = w_finish_time[i+1] -q->s_work.arrive_time;p rintf("第%d个系统执行的作业到达时间:%d",i+2,q->s_work.arrive_time);p rintf("编号是:%d ",q->s_work.id);p rintf("服务时间是:%d\n",q->s_work.work_time);p rintf("完成时间是:%d ",w_finish_time[i+1]);p rintf("周转时间是:%d \n",w_rel_time[i+1]);}void showmenu(){printf("**********************************\n"); p rintf("请选择你要执行的命令~: \n");p rintf("1:先来先服务算法\n");p rintf("2:短作业优先算法\n");p rintf("3: 高响应比优先算法\n");p rintf("0: 退出菜单\n");p rintf("**********************************\n"); }void HRRN(){i nt w_rel_time[10];i nt w_finish_time[10];f loat rel_time = 0;f loat priority; //计算优先权s rand(time(0));i nt i;i nt j = 0;P NODE pHead = (PNODE)malloc(sizeof(NODE));i f (NULL == pHead){printf("分配失败, 程序终止!\n");exit(-1);}P NODE pTail = pHead;p Tail->pNext = NULL; //定义该链表有头结点,且第一个节点初始化为空f or(i=0;i<10;i++) //定义了十个进程{PNODE pNew = (PNODE)malloc(sizeof(NODE));if (NULL == pNew){printf("分配失败, 程序终止!\n");exit(-1);}pNew->s_work.id = rand()%100;pNew->s_work.arrive_time = rand()%10;pNew->s_work.work_time = rand()%10+1;pTail->pNext = pNew;pNew->pNext = NULL;pTail = pNew;}P NODE p = pHead->pNext; //p指向第一个节点w hile (NULL != p){printf("第%d个作业的编号是:%d\t",j+1,p->s_work.id);printf("第%d个作业到达时间:%d\t",j+1,p->s_work.arrive_time);printf("第%d个作业服务时间:%d\t",j+1,p->s_work.work_time);printf("\n");p = p->pNext;printf("\n");j++;}p = pHead->pNext;P NODE q = p; //p,q都指向第一个节点p = p->pNext;w hile(p != NULL){if(p->s_work.arrive_time < q->s_work.arrive_time) q = p;p = p->pNext;}P NODE r = pHead->pNext; //r也指向第一个节点i nt cnt = 0; //记录所有节点数据域中到达时间最短且相等的个数w hile(r!= NULL){if( r->s_work.arrive_time == q->s_work.arrive_time ) cnt++;r = r->pNext;}p = pHead->pNext;w hile(p != NULL) //在相等到达时间的作业中找服务时间最短的作业{if(cnt > 1){if( p->s_work.arrive_time ==q->s_work.arrive_time )if( p->s_work.work_time < q->s_work.work_time )q = p;p = p->pNext;}elsep =NULL;} //确定q所指作业最先到达且服务时间最短w_finish_time[0] = q->s_work.arrive_time +q->s_work.work_time;w_rel_time[0] = w_finish_time[0] -q->s_work.arrive_time;p rintf("第1个系统执行的作业到达时间:%d",q->s_work.arrive_time);p rintf("编号是:%d ",q->s_work.id);p rintf("服务时间是:%d \n",q->s_work.work_time); p rintf("完成时间是:%d ",w_finish_time[0]);p rintf("周转时间是:%d \n",w_rel_time[0]);p = pHead; //寻找q的前一个节点,方便删掉q节点w hile( p->pNext != q ){p = p->pNext;}p->pNext = q->pNext;f ree(q);q = NULL; //已经找到并执行第一个进程,执行完之后又将其删除了f or(i=0;i<9&&!Is_empty(pHead);i++){printf("现在系统还剩%d个作业!\n",cnt_work(pHead));do_work_1(pHead,w_finish_time,i);q = priorit(pHead);show(w_finish_time,i,q,w_rel_time);p = pHead; //寻找q的前一个节点,方便删掉q节点while( p->pNext != q ){p = p->pNext;}p->pNext = q->pNext;free(q);q = NULL;}f or(j=0;j<10;j++){rel_time += w_rel_time[j];}printf("平均周转时间:%f\n",rel_time/10);}void do_work_1(PNODE pHead,int *w_finish_time,int i) {P NODE p,q;i nt cnt = 0; //计数器清0,计算当前作业完成时,系统中有多少个作业已经到达p = pHead->pNext;q = p;w hile(p != NULL){if( p->s_work.arrive_time <= w_finish_time[i] ){cnt ++;q = p;p = p->pNext;}else{p = p->pNext;}} //q指向当前到达时间小于刚刚完成的作业,但有可能有另外几个进程也已经到达了,所以要进行下面的判断p rintf("系统中有%d个作业在当前作业完成时已经到达!\n",cnt);p = pHead->pNext;w hile(p != NULL){if(cnt>1) //说明此时有好几个都已经到达了{if(p->s_work.arrive_time <= w_finish_time[i]){p->s_work.wait = w_finish_time[i] -p->s_work.arrive_time;p = p->pNext;}else{p->s_work.wait = 0;p = p->pNext;}}else //当前作业完成时,没有作业到达的情况{p = p->pNext; //此时p指向第一个节点,q指向第二个节点,还是找最先到达的while( p != NULL ){if( p->s_work.arrive_time <q->s_work.arrive_time )q = p;p = p->pNext;}w_finish_time[i+1] = q->s_work.arrive_time +q->s_work.work_time;return;}}w_finish_time[i+1] = w_finish_time[i] +q->s_work.work_time;}PNODE priorit(PNODE pHead){P NODE p = pHead->pNext;w hile(p != NULL){if(p->s_work.wait > 0){p->s_work.priority = (p->s_work.wait +p->s_work.work_time) / p->s_work.work_time; //计算每一个已经等待的进程的优先等级p = p->pNext;}elsep = p->pNext;}p = pHead->pNext;P NODE q;q = p;p = p->pNext; //p已经指向第二个节点w hile(p != NULL){if(p->s_work.wait > 0){if(p->s_work.priority > q->s_work.priority){q = p;p = p->pNext;}elsep = p->pNext;}elsep = p->pNext;}p rintf("该进程优先级最高,为:%f\n",q->s_work.priority);return q;}实验结果:系统自动为每个算法模拟分配五个作业,同时随机生成作业的编号,作业的到达时间,作业估计运行的时间。
操作系统典型调度算法
操作系统典型调度算法在操作系统中存在多种调度算法,下⾯介绍⼏种常⽤的调度算法。
先来先服务(FCFS)调度算法FCFS调度算法是⼀种最简单的调度算法,FCFS调度算法每次从就绪队列中选择最先进⼊该队列的进程,将处理机分配给它,使之投⼊运⾏,直到完成或因某种原因⽽阻塞时才释放处理机。
下⾯通过⼀个实例来说明FCFS调度算法的性能。
假设系统中有4个作业,它们的提交时间分别是8、8.4、8.8、9,运⾏时间依次是2、1、0.5、0.2,系统⾤⽤FCFS调度算法,这组作业的平均等待时间、平均周转时间和平均带权周转时间见表2-3。
表2-3 FCFS调度算法的性能作业号提交时间运⾏时间开始时间等待时间完成时间周转时间带权周转时间18280102128.4110 1.611 2.6 2.638.80.511 2.211.5 2.7 5.4490.211.5 2.511.7 2.713.5平均等待时间 t = (0+1.6+2.2+2.5)/4=1.575平均周转时间 T = (2+2.6+2.7+2.7)/4=2.5平均带权周转时间 W = (1+2.6+5.牡13.5)/4=5.625FCFS调度算法属于不可剥夺算法。
从表⾯上看,它对所有作业都是公平的,但若⼀个长作业先到达系统,就会使后⾯许多短作业等待很长时间,因此它不能作为分时系统和实时系统的主要调度策略。
但它常被结合在其他调度策略中使⽤。
例如,在使⽤优先级作为调度策略的系统中,往往对多个具有相同优先级的进程按FCFS原则处理。
FCFS调度算法的特点是算法简单,但效率低;对长作业⽐较有利,但对短作业不利(相对SJF和⾼响应⽐);有利于CPU繁忙型作业,⽽不利于I/O繁忙型作业。
短作业优先(SJF)调度算法短作业(进程)优先调度算法是指对短作业(进程)优先调度的算法。
短作业优先(SJF)调度算法是从后备队列中选择⼀个或若⼲个估计运⾏时间最短的作业,将它们调⼊内存运⾏。
常用的调度优化算法公式
常用的调度优化算法公式常用的调度优化算法有很多种,每种算法都有其特定的优势和适用的场景。
本文将介绍几种常见的调度优化算法,并对其进行简要的概述和比较。
1. 先来先服务(First-Come, First-Served, FCFS)先来先服务是最简单的调度算法之一,它按照作业到达的顺序进行调度。
即使作业的执行时间不同,也会按照它们到达的顺序进行执行。
这种算法的优点是简单易实现,但缺点是可能导致长作业等待时间过长,而短作业等待时间过短。
2. 最短作业优先(Shortest Job First, SJF)最短作业优先算法会优先调度执行时间最短的作业。
这种算法可以最大程度地减少作业的等待时间,但需要事先知道每个作业的执行时间。
当作业的执行时间难以估计时,这种算法可能会导致长作业等待时间过长。
3. 优先级调度(Priority Scheduling)优先级调度算法会为每个作业指定一个优先级,并按照优先级进行调度。
优先级可以按照作业的重要性、紧急程度或其他因素进行设置。
这种算法可以根据实际需求进行灵活的调度,但需要合理设置优先级,否则可能导致某些作业一直得不到执行。
4. 时间片轮转(Round Robin, RR)时间片轮转算法将每个作业分配一个固定的时间片,作业在这个时间片内执行,然后切换到下一个作业。
如果一个作业在一个时间片内没有完成,它将被放到队列的末尾继续执行。
这种算法可以确保每个作业都有机会执行,但可能导致一些长作业的等待时间过长。
5. 多级反馈队列(Multilevel Feedback Queue, MLFQ)多级反馈队列算法将作业分成多个队列,并为每个队列分配不同的优先级。
作业首先进入最高优先级的队列,如果在一个时间片内没有完成,它将被移到下一个优先级的队列,直到完成或到达最低优先级的队列。
这种算法可以平衡长作业和短作业的执行时间,但需要合理设置队列数量和优先级。
以上是几种常见的调度优化算法,它们各有优缺点,在不同的场景中选择适合的算法可以最大程度地提高系统的性能和效率。
关于作业调度算法
关于作业调度算法作业调度算法是一种用来管理计算机系统中作业的执行顺序的方法。
在计算机系统中,有很多不同的作业需要执行,作业调度算法可以根据不同的策略和需求,确定作业的执行顺序,以提高系统的效率和性能。
作业调度算法的目标是尽量减少作业的等待时间和系统的响应时间,同时以最小化系统资源的使用为前提。
通过合理的作业调度算法,可以充分利用计算机系统的资源,提高系统的吞吐量和效率。
常见的作业调度算法包括先来先服务(FCFS)、短作业优先(SJF)、最高优先级优先(HPF)、时间片轮转(RR)等。
这些算法根据不同的原则和需求,选择适合的作业执行顺序。
先来先服务(FCFS)是一种最简单的作业调度算法,它按照作业的提交顺序进行调度。
这种算法适用于作业的执行时间相对较均匀的情况,但如果有长时间的作业阻塞其他作业的执行,就可能导致系统的响应时间变长。
短作业优先(SJF)算法则根据作业的执行时间进行排序,在每次调度时选择执行时间最短的作业。
这种算法可以最大限度地减少作业的等待时间,但如果有一些长时间的作业等待执行,可能会导致长作业等待时间过长。
最高优先级优先(HPF)算法根据作业的优先级确定执行顺序,优先级越高的作业越先执行。
这种算法可以根据作业的重要性进行调度,但如果有一些优先级较低的作业等待执行,可能会导致长时间的等待。
时间片轮转(RR)算法将系统的时间片分配给每个作业,每个作业在一个时间片内执行一定的时间,然后切换到下一个作业。
这种算法可以均衡地利用系统的资源,但如果一些作业需要很长的时间完成,可能会导致其他作业的等待时间变长。
除了这些常见的作业调度算法,还有一些其他的算法,如多级反馈队列调度(MLFQ)、最短剩余时间优先(SRTF)等。
这些算法根据具体的系统需求和性能目标,选择适合的调度策略。
总之,作业调度算法是计算机系统中非常重要的一部分,它可以根据不同的策略和需求,对作业的执行顺序进行管理,提高系统的效率和性能。
操作系统各种调度算法
操作系统各种调度算法⼀、批处理作业调度算法1.先来先服务调度算法First Come,First Served.(FCFS):就是按照各个作业进⼊系统的⾃然次序来调度作业。
这种调度算法的优点是实现简单,公平。
其缺点是没有考虑到系统中各种资源的综合使⽤情况,往往使短作业的⽤户不满意,因为短作业等待处理的时间可能⽐实际运⾏时间长得多。
2.短作业优先调度算法shortest job first(SPF): 就是优先调度并处理短作业,所谓短是指作业的运⾏时间短。
⽽在作业未投⼊运⾏时,并不能知道它实际的运⾏时间的长短,因此需要⽤户在提交作业时同时提交作业运⾏时间的估计值。
3.最⾼响应⽐优先算法Hightest response-radio next(HRN):FCFS可能造成短作业⽤户不满,SPF可能使得长作业⽤户不满,于是提出HRN,选择响应⽐最⾼的作业运⾏。
响应⽐=1+作业等待时间/作业处理时间。
4. 基于优先数调度算法Highest Possible Frequency(HPF):每⼀个作业规定⼀个表⽰该作业优先级别的整数,当需要将新的作业由输⼊井调⼊内存处理时,优先选择优先数最⾼的作业。
5.均衡调度算法,即多级队列调度算法基本概念:作业周转时间(Ti)=完成时间(Tei)-提交时间(Tsi)作业平均周转时间(T)=周转时间/作业个数作业带权周转时间(Wi)=周转时间/运⾏时间响应⽐=(等待时间+运⾏时间)/运⾏时间⼆、进程调度算法1.先进先出算法(FIFO):按照进程进⼊就绪队列的先后次序来选择。
即每当进⼊进程调度,总是把就绪队列的队⾸进程投⼊运⾏。
2. 时间⽚轮转算法Round Robin(RR):分时系统的⼀种调度算法。
轮转的基本思想是,将CPU的处理时间划分成⼀个个的时间⽚,就绪队列中的进程轮流运⾏⼀个时间⽚。
当时间⽚结束时,就强迫进程让出CPU,该进程进⼊就绪队列,等待下⼀次调度,同时,进程调度⼜去选择就绪队列中的⼀个进程,分配给它⼀个时间⽚,以投⼊运⾏。
作业调度算法
1.1 先来先服务调度算法
先来先服务调度算法是指每次从作业后备队列中选择最先 进入该队列的一个或几个作业,将它们调入内存,分配必要的 资源,创建进程并放入就绪队列,即哪一个作业先提交给系统, 就先运行哪一个作业。
2021年1月27日星期三
1.2 短作业优先调度算法
短作业优先调度算法是指每次调度总是从作业后备队 列中选择一个或几个估计运行时间最短的作业,将它们调 入内存,分配必要的资源,创建进程并放入就绪队列。
2021年1月27日星期三
由响应比的计算公式可以看出: (1)作业服务时间越短响应比越高,短小作业越能较快得到系统 响应。因此该算法有利于短作业。 (2)对于服务时间相同的作业,等待时间长的作业响应比高,优 先得到调度,即先来的作业优先。 (3)一个服务时间很长的作业在系统中等待的时间不断增加,响 应比就会不断提高,被调用的可能性随之不断增大。这种算法可以避 免大作业在系统中长期得不到调度。
因此,该算法既照顾了短作业,又兼顾了长作业,不足之处是每 次调度都要计算所有后备作业的响应比,增加了系统开销。
2021年1月27日星期三
2021年1月27日星期三
1.3 优先级调度算法
优先级调度算法也称为优先权调度算法,是基于作业运述作业运行的 紧迫程度。
作业调度程序每次从作业后备队列中选择一个或几个优先级最高 的作业,将它们调入内存,分配必要的资源,创建进程并放入就绪队 列。
这种算法总是优先调度优先级高的作业,有可能使低优先级的作 业处于“饥饿”状态。
2021年1月27日星期三
1.4 高响应比优先调度算法
高响应比优先调度算法是FCFS和SJF两种算法的折中,既考虑作业 进入系统的时间,又顾及作业的运行时间的长度。响应比R可以定义如 下:
操作系统作业调度算法
操作系统作业调度算法在计算机操作系统中,作业调度算法起着至关重要的作用。
它决定了哪些作业能够被优先处理,以及如何合理地分配系统资源,以提高整个系统的性能和效率。
让我们先来理解一下什么是作业调度。
简单来说,当有多个作业等待被处理时,操作系统需要决定哪个作业先进入处理状态,哪个作业需要等待。
这就像是在一个繁忙的餐厅,服务员需要决定先为哪桌客人上菜一样。
常见的作业调度算法有先来先服务(FCFS)、短作业优先(SJF)、优先级调度、高响应比优先调度和时间片轮转调度等。
先来先服务算法是最简单直观的一种。
它按照作业到达的先后顺序进行调度。
就好比排队买票,先到的人先买。
这种算法的优点是实现简单、公平,大家都按照先来后到的顺序。
但它也有明显的缺点,如果先到达的作业执行时间很长,后面的短作业就需要长时间等待,可能会导致系统的平均周转时间较长。
短作业优先算法则是优先处理执行时间短的作业。
这就像是在餐厅中,先为点了简单菜品的客人上菜。
它的优点是能够减少平均周转时间,提高系统的吞吐量。
但问题是,我们很难准确预知作业的执行时间,而且如果一直有更短的作业到来,长作业可能会被“饿死”。
优先级调度算法为每个作业赋予一个优先级,优先级高的作业先被处理。
这有点像医院的急诊室,病情紧急的患者优先得到治疗。
这种算法可以灵活地根据作业的重要性或紧急程度来安排处理顺序,但确定合理的优先级可能会比较困难,而且如果优先级设置不当,也可能导致一些作业长时间得不到处理。
高响应比优先调度算法综合考虑了作业的等待时间和执行时间。
响应比=(等待时间+执行时间)/执行时间。
这样既照顾了先来的作业,又不会让短作业等待太久。
它在一定程度上克服了先来先服务和短作业优先算法的缺点,但计算响应比也会增加系统的开销。
时间片轮转调度算法将 CPU 时间分成固定大小的时间片,每个作业轮流使用一个时间片。
如果作业在一个时间片内没有完成,就会被放到队列的末尾等待下一轮。
这就像是大家轮流发言,每人都有一定的时间。
作业调度 算法设计
作业调度算法设计作业调度算法设计作业调度是在操作系统中的一个重要问题,涉及到多个任务的执行顺序和优先级,以及如何合理地分配资源和时间片,以提高系统的效率和响应速度。
本文将探讨几种常见的作业调度算法设计。
1. 先来先服务(FCFS)调度算法:先来先服务是最简单的作业调度算法,按照作业到达的先后顺序进行调度。
当一个作业到达后,它将占用CPU直到完成,然后才会调度下一个作业。
这种算法实现容易,但是有可能引发"饥饿"的问题,即长作业抢占了CPU资源,导致短作业等待时间过长。
2. 最短作业优先(SJF)调度算法:最短作业优先调度算法是根据作业的执行时间进行调度。
当一个作业到达后,调度器将选择执行时间最短的作业先运行。
这种算法可以最大程度地减少作业的等待时间和周转时间,但是需要预先知道每个作业的执行时间,而实际情况下往往无法准确估计。
3. 优先级调度算法:优先级调度算法给每个作业分配一个优先级,根据优先级的高低进行调度。
优先级可以根据作业类型、作业重要性或其他标准来确定。
这种算法能够充分考虑作业的紧迫性和重要性,但是可能导致优先级较低的作业长时间等待,产生"饥饿"问题。
4. 时间片轮转调度算法:时间片轮转调度算法是一种基于时间片的多道程序设计调度算法。
每个作业被分配一个时间片,当时间片耗尽后,作业会被暂停并切换到下一个作业执行。
这种算法实现简单,能够实现公平调度和响应时间较好,但是对于长时间运行的作业不太友好。
综上所述,作业调度算法的选择可以根据具体需求和系统情况来确定。
FCFS 适用于简单需求,SJF适用于作业执行时间已知的情况,优先级调度适用于根据作业的重要性进行调度,时间片轮转算法适用于多道程序设计的环境。
根据实际情况选择合适的作业调度算法,能够提高系统的效率和响应速度。
几种操作系统调度算法
几种操作系统调度算法操作系统调度算法是操作系统中的关键机制之一,用于确定进程的执行顺序和分配处理器时间片。
不同的调度算法可以根据不同的应用需求和系统性能进行选择。
下面将介绍几种常见的操作系统调度算法。
1.先来先服务(FCFS)调度算法:即按照进程到达的先后顺序进行调度。
对于短作业而言,这种算法可以保证公平性,但对于长作业而言,可能会导致等待时间过长的问题。
2.最短作业优先(SJF)调度算法:即选择执行时间最短的作业进行调度。
这种算法可以减少平均等待时间,但需要提前准确预测作业的执行时间,对于实时系统或具有多变性质的作业调度来说,这种算法可能存在不可行性。
3.优先级调度算法:为每个进程分配一个优先级,并按照优先级大小进行调度。
可以根据作业的重要程度、紧迫程度等因素来分配优先级。
优先级调度算法可以优先保证重要作业的执行,但还需要解决优先级反转、饥饿等问题。
4.时间片轮转(RR)调度算法:将处理器时间分成固定大小的时间片,每个进程在一个时间片的执行时间后被挂起,然后按照队列中的顺序进行下一个时间片的调度。
这种算法可以保证每个进程都有执行的机会,但对于长作业而言,可能会导致响应时间过长的问题。
5.最高响应比优先(HRRN)调度算法:根据作业等待时间和作业执行时间的比值来选择下一个要执行的作业。
这种算法可以根据作业的等待情况来自动调整作业的执行优先级,适用于具有多变性质的作业调度。
6.多级反馈队列(MFQ)调度算法:将进程按照优先级分成多个队列,初始时将所有进程放入第一级队列,每个队列的时间片大小逐级递增。
当进程在其中一级队列用完时间片后,如果仍然有剩余时间,则将进程移到下一级队列。
这种算法可以根据作业的执行情况进行动态调整,适用于提高系统吞吐量和减少响应时间。
以上是几种常见的操作系统调度算法,每种算法都有其优点和缺点,具体选择哪种算法需要根据系统的需求和特点进行综合考虑。
为了提高系统性能和用户体验,操作系统调度算法的研究与优化一直是操作系统领域的重要研究方向。
作业调度算法
D
10:50
20分
6
(1) 列出所有作业进入内存时间及结束时间 (2)计算平均周转时间
(1)所有作业的进入内存时间和结束时间:
作业 名 到达 时间 估计运 优先 行时间 数 进入内 开始执 结束 存时间 行时间 时间 周转 时间
A
B C D
10:00 40分
10:20 30分 10:30 50分 10:50 20分
作业调度算法
先来先服务FCFS
进程名 到达 服务 开始执 结束 时间 时间 行时间 时间 周转 带权周 时间 转时间
A B C D E
0 1 2 3 4
4 3 5 2 4
0 4 7 12 14
4 7 12 14 18
4 6 10 11 14
1 2 2 5.5 3.5
平均周转时间:9,平均带权周转时间:2.8
10:00 10:20 11:30 10:35 10:55
10:00 10:25 11:30 10:55 11:15
10:25 25分 10:55 35分 11:40 70分 11:15 40分 11:30 35分
5、在某多道程序系统中,供用户使用的内存空 间有100K,磁带机2台,打印机1台。系统采用 可变式分区分配方式管理内存,对磁带机和打 印机采用静态分配方式,并假设输入/输出操 作的时间忽略不计。现有一作业序列如下所示:
0.3小时 15K
2
3
10.3
10.5
0.5小时 60K
0.4小时 50K
4
5
10.6
10.7
0.4小时 10K
0.2小时 20K
平均周转时间:
作业
提交时 预计运 间 行时间
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验二作业调度实验一. 目的要求:用高级语言编写和调试一个或多个作业调度的模拟程序,以加深对作业调度算法的理解。
二. 例题:为单道批处理系统设计一个作业调度程序。
由于在单道批处理系统中,作业一投入运行,它就占有计算机的一切资源直到作业完成为止,因此调度作业时不必考虑它所需要的资源是否得到满足,它所占用的 CPU时限等因素。
作业调度算法:采用先来先服务(FCFS)调度算法,即按作业提交的先后次序进行调度。
总是首先调度在系统中等待时间最长的作业。
每个作业由一个作业控制块JCB表示,JCB可以包含如下信息:作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。
作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。
每个作业的最初状态总是等待W。
各个等待的作业按照提交时刻的先后次序排队,总是首先调度等待队列中队首的作业。
每个作业完成后要打印该作业的开始运行时刻、完成时刻、周转时间和带权周转时间,这一组作业完成后要计算并打印这组作业的平均周转时间、带权平均周转时间。
调度算法的流程图如下图所示。
三 . 实习题:1、编写并调试一个单道处理系统的作业等待模拟程序。
作业等待算法:分别采用先来先服务(FCFS),最短作业优先(SJF)、响应比高者优先(HRN)的调度算法。
对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间,以及这组作业的平均周转时间及带权平均周转时间,以比较各种算法的优缺点。
2、编写并调度一个多道程序系统的作业调度模拟程序。
作业调度算法:采用基于先来先服务的调度算法。
可以参考课本中的方法进行设计。
对于多道程序系统,要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求。
3、编写并调试一个多道程序系统的作业调度模拟程序。
作业调度算法:采用基于优先级的作业调度。
可以参考课本中的例子自行设计。
三 . 实验过程:1、编写并调试一个单道处理系统的作业等待模拟程序。
先来先服务(FCFS):main.cpp:/***先来先服作业调度算法模拟*/#include <string>#include <iostream>#define MAX_SOURCE 1000 //资源总数(对于单通道的作业调度可以忽略系统资源问题)using namespace std;struct jobCB{string name;double subtime;//提交时间double runtime;//运行时间double source;//资源char state;//进程状态struct jobCB *next; //链指针}*ready,*rail,*p;int length;double maxsource;double now_source;double allTi;//总周转时间double allWi;//总带权周转时间double time;//时钟void init(){time=0;length=0;allTi=0;allWi=0;maxsource=MAX_SOURCE;now_source=0;rail=ready=p=NULL;}void destroy(){maxsource+=p->source;//释放资源time+=p->runtime;p->state='f';delete p;}void running(){p->state='r';double Tc = time+ p->runtime;//完成时刻double Ti = Tc - p->subtime;//周转时间double Wi = Ti/p->runtime;//带权周转时间cout<<"\n作业"<<p->name<<"信息:"<<endl;cout<<"\n录入时间运行时间开始运行的时刻完成时刻周转时间带权周转时间"<<endl;cout<<"\n"<<p->subtime<<"\t "<<p->runtime<<"\t "<<time<<" \t"<<Tc<<"\t "<<Ti<<" \t"<<Wi<<endl;allTi+=Ti;allWi+=Wi;destroy();}void display(){cout<<"\n----------------------------------------------------------"<<endl;for(int i=0; i< length; i++){p = ready;ready = ready->next;p->state = 'r';running();}cout<<"\n----------------------------------------------------------"< <endl;}void in_queue(){now_source+=p->source;//分配资源给作业if(maxsource>=now_source){if(ready==NULL){ready=rail=p;}else{rail->next=p;rail=p;}length ++;}else{now_source-=p->source;//回退cout<<"没有足够资源!"<<endl;return;}}void input(){int n;cout<<" --先来先服作业调度算法模拟--"<<endl;cout<<"请输入作业数: "<<endl;cin>>n;for(int i = 0; i < n; i++){p = new jobCB;cout<<"当前作业录入时间:"<<time;cout<<"\n请输入作业名: ";cin>>p->name;cout<<"\n请输入作业所需的运行时间: ";cin>>p->runtime;cout<<"\n请输入作业所需的资源: ";cin>>p->source;p->state = 'w';p->subtime = time;time++;p->next = NULL;in_queue();}}int main(){init();input();display();cout<<"\n这组作业的平均周转时间为: "<<allTi / length<<endl;cout<<"\n这组作业的带权平均周转时间为: "<<allWi / length<<endl; return 0;}(程序测试运行结果在附件里)短作业优先(SJF):main.cpp:/***短作业优先作业调度算法模拟*/#include <string>#include <iostream>#define MAX_SOURCE 1000using namespace std;struct jobCB{string name;double subtime;//提交时间double runtime;//运行时间double source;//资源char state;//进程状态struct jobCB *next; //链指针}*ready,*rail,*p;int length;double maxsource; //资源总数,对于单通道作业调度,资源部分可以去掉(由于当时写多道时是在单道上直接修改的,所以这里多道部分仍然在)double now_source; //当前资源double allTi;//总周转时间double allWi;//总带权周转时间double time;//时钟void init(){time=0;length=0;allTi=0;allWi=0;maxsource=MAX_SOURCE;now_source=0;rail=ready=p=NULL;}void destroy(){Maxsource+=p->source;//释放资源time+=p->runtime;p->state='f';delete p;}void running(){p->state='r';double Tc = time+ p->runtime;//完成时刻double Ti = Tc - p->subtime;//周转时间double Wi = Ti/p->runtime;//带权周转时间cout<<"\n作业"<<p->name<<"信息:"<<endl;cout<<"\n录入时间运行时间开始运行的时刻完成时刻周转时间带权周转时间"<<endl;cout<<"\n"<<p->subtime<<"\t "<<p->runtime<<"\t "<<time<<" \t"<<Tc<<"\t "<<Ti<<" \t"<<Wi<<endl;allTi+=Ti;allWi+=Wi;destroy();}void display(){cout<<"\n----------------------------------------------------------"<<endl;for(int i=0; i< length; i++){p = ready;ready = ready->next;p->state = 'r';running();}cout<<"\n----------------------------------------------------------"<}void in_queue(){int flag=0;now_source+=p->source;//分配资源给作业jobCB *q1,*q2;if(maxsource>=now_source){if(ready==NULL){ready=rail=p;}else{if(p->runtime<ready->runtime){p->next=ready;ready=p;}else {q1=ready;q2=ready->next;while(q2!=NULL){if(q2->runtime>p->runtime) {p->next=q2;q1->next=p;flag=1;}q1=q2;q2=q2->next;}if(flag==0)q1->next=p;}}length ++;}else{now_source-=p->source;//回退cout<<"没有足够资源!"<<endl;return;}void input(){int n;cout<<" ---短作业优先作业调度算法模拟---"<<endl;cout<<"请输入作业数: "<<endl;cin>>n;for(int i = 0; i < n; i++){p = new jobCB;cout<<"当前作业录入时间:"<<time;cout<<"\n请输入作业名: ";cin>>p->name;cout<<"\n请输入作业所需的运行时间: ";cin>>p->runtime;cout<<"\n请输入作业所需的资源: ";cin>>p->source;p->state = 'w';p->subtime = time;time++;p->next = NULL;in_queue();}}int main(){init();input();display();cout<<"\n这组作业的平均周转时间为: "<<allTi / length<<endl;cout<<"\n这组作业的带权平均周转时间为: "<<allWi / length<<endl; return 0;}(程序测试运行结果在附件里)响应比高者优先(HRN):main.cpp:/***响应比高优先作业调度算法模拟*/#include <string>#include <iostream>#include <list>#define MAX_SOURCE 1000using namespace std;struct jobCB{string name;double subtime;//提交时间double runtime;//运行时间double source;//资源char state;//进程状态struct jobCB *next; //链指针}*p;list <jobCB*> jobqueue; //声明作业调度队列,使用STL(标准模板库)的listlist <jobCB*> ::iterator it;int length;double maxsource;double now_source;double allTi;//总周转时间double allWi;//总带权周转时间double time;//时钟double inputfinishtime;//输入结束时间void init(){time=0;length=0;allTi=0;allWi=0;inputfinishtime=0;maxsource=MAX_SOURCE;now_source=0;p=NULL;}void destroy(){maxsource+=p->source;time+=p->runtime;p->state='f';}void running(){p->state='r';double Tc = time+ p->runtime;//完成时刻double Ti = Tc - p->subtime;//周转时间double Wi = Ti/p->runtime;//带权周转时间cout<<"\n作业"<<p->name<<"信息:"<<endl;cout<<"\n录入时间运行时间开始运行的时刻完成时刻周转时间带权周转时间响应比"<<endl;cout<<"\n"<<p->subtime<<"\t "<<p->runtime<<"\t "<<time<<" \t"<<Tc<<"\t "<<Ti<<" \t"<<Wi<<"\t"<<(inputfinishtime-p->subtime)/p->runtime+1<<endl;allTi+=Ti;allWi+=Wi;destroy();}void display(){cout<<"\n----------------------------------------------------------"<<endl;for(int i=0; i< length; i++){p=jobqueue.front();//取出队首元素jobqueue.pop_front();//出队p->state = 'r';running();}cout<<"\n----------------------------------------------------------"<<endl;}void in_queue()//按所有作业到达后再计算响应比(即固定优先比),所有作业都提交完成的时间是n*提交单个作业时间(1){now_source+=p->source;//分配资源给作业if(maxsource>=now_source){jobqueue.push_back(p);length ++;}else{now_source-=p->source;//回退cout<<"没有足够资源!"<<endl;return;}}double makeout_ResR(jobCB *p)//算出响应比,因为优先比是waittime/runtime+1,所以这里直接比较waittime/runtime->(inputfinishtime-subtime)/runtime{//cout<<(inputfinishtime-p->subtime)/p->runtime<<" \t";return (inputfinishtime-p->subtime)/p->runtime;}bool compare(jobCB *first,jobCB *second) //用于list排序的compare函数{if(makeout_ResR(first)>makeout_ResR(second)) return true;else return false;}void input(){int n;cout<<" ---响应比优先作业调度算法模拟---"<<endl;cout<<"请输入作业数: "<<endl;cin>>n;inputfinishtime=n*1;for(int i = 0; i < n; i++){p = new jobCB;cout<<"当前作业录入时间:"<<time;cout<<"\n请输入作业名: ";cin>>p->name;cout<<"\n请输入作业所需的运行时间: ";cin>>p->runtime;cout<<"\n请输入作业所需的资源: ";cin>>p->source;p->state = 'w';p->subtime = time;time++;p->next = NULL;in_queue();}jobqueue.sort(compare);}int main(){init();input();display();cout<<"\n这组作业的平均周转时间为: "<<allTi / length<<endl;cout<<"\n这组作业的带权平均周转时间为: "<<allWi / length<<endl; return 0;}(程序测试运行结果在附件里)2、编写并调度一个多道程序系统的作业调度模拟程序。