各类作业调度算法

合集下载

用于作业调度的算法

用于作业调度的算法

用于作业调度的算法作业调度是计算机操作系统中的一个重要概念,它指的是在多个进程同时运行时,如何合理地分配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; 来先服务算法该算法严格按照各作业到达时间来为其分配进程和资源,实验的结果见截图,最后算出该算法五个作业的平均周转时间。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 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、编写并调度一个多道程序系统的作业调度模拟程序。

相关文档
最新文档