操作系统作业调度算法

合集下载

用于作业调度的算法

用于作业调度的算法

用于作业调度的算法作业调度是计算机操作系统中的一个重要概念,它指的是在多个进程同时运行时,如何合理地分配CPU资源,使得系统能够高效地完成各项任务。

作业调度算法是实现作业调度的关键,下面将详细介绍几种常见的作业调度算法。

一、先来先服务(FCFS)算法先来先服务(FCFS)算法是最简单也是最容易实现的一种作业调度算法。

该算法按照进程到达时间的顺序依次执行,即当一个进程到达后,如果当前没有正在执行的进程,则立即执行该进程;否则将该进程加入等待队列中,并等待前面所有进程执行完毕后再进行处理。

FCFS算法优点在于简单易实现,并且保证了公平性。

但由于没有考虑到不同进程的优先级和执行时间等因素,因此可能会导致长任务等待时间过长、短任务响应时间过长等问题。

二、短作业优先(SJF)算法短作业优先(SJF)算法是一种根据作业长度进行排序的调度策略。

该算法按照各个进程需要占用CPU时间片长度进行排序后依次执行,即当一个新的进程到达时,如果其需要占用的时间片长度比当前正在执行的进程短,则立即切换到该进程进行处理,否则将该进程加入等待队列中,并等待前面所有进程执行完毕后再进行处理。

SJF算法优点在于能够最大限度地缩短作业响应时间,提高系统的吞吐量。

但由于需要预测每个进程需要占用的时间片长度,因此实现起来较为困难,并且可能会出现“饥饿”现象,即长时间等待CPU资源的进程无法得到及时处理。

三、优先级调度算法优先级调度算法是一种按照不同进程的优先级进行排序的调度策略。

该算法将每个进程赋予一个优先级值,根据优先级值高低依次执行,即当一个新的进程到达时,如果其优先级比当前正在执行的进程高,则立即切换到该进程进行处理,否则将该进程加入等待队列中,并等待前面所有优先级更高的进程执行完毕后再进行处理。

优先级调度算法可以根据不同任务类型和紧急性进行灵活调整,并且可以避免长任务等待时间过长、短任务响应时间过长等问题。

但由于可能会出现“饥饿”现象和优先级反转等问题,因此需要进行适当的优化和调整。

操作系统作业调度算法实验

操作系统作业调度算法实验

操作系统作业调度算法实验
操作系统作业调度算法实验可以让你更深入地理解作业调度的概念和方法,以下是实验的基本步骤和内容:
一、实验目的
掌握作业调度的基本概念和算法原理。

理解不同作业调度算法的特点和优缺点。

通过实验验证作业调度算法的正确性和性能。

二、实验内容
实验准备:准备一台计算机或模拟器,安装操作系统,并准备好实验所需的作业。

实验步骤:
(1)编写作业描述文件,包括作业的名称、到达时间、所需资源等信息。

(2)实现先来先服务(FCFS)、最短作业优先(SJF)、最高响应比优先(HRN)等作业调度算法,并编写相应的调度程序。

(3)将作业按照一定的顺序输入到调度程序中,并记录每个作业的执行时间、等待时间等参数。

(4)根据记录的数据计算平均周转时间、平均带权周转时间等指标,分析不同调度算法的性能差异。

(5)根据实验结果,分析不同调度算法的优缺点,并给出改进建议。

实验报告:整理实验数据和结果,撰写实验报告,包括实验目的、实验内容、实验步骤、实验结果、分析和结论等部分。

三、实验注意事项
在实验过程中,要注意保证作业的公平性,避免某些作业一直得不到执行的情况发生。

在实验过程中,要注意观察和记录每个作业的执行时间和等待时间等参数,以便后续的分析和比较。

在实验过程中,要注意保证系统的稳定性和可靠性,避免出现意外情况导致实验结果不准确。

在实验过程中,要注意遵守实验室规定和操作规程,确保实验过程的安全和顺利进行。

操作系统中常用作业调度算法的分析

操作系统中常用作业调度算法的分析

操作系统中常用作业调度算法的分析作业调度算法是操作系统中非常重要的一部分,它负责决定哪个进程应该被调度执行、以及在什么时候执行。

不同的作业调度算法会对系统的性能和资源利用率产生不同的影响,因此了解和分析常用的作业调度算法对于优化系统性能至关重要。

在操作系统中,常用的作业调度算法包括先来先服务(FCFS)、短作业优先(SJF)、最高响应比优先(HRRN)、优先级调度、轮转调度和多级反馈队列调度等。

下面对这些常见的作业调度算法进行详细分析。

1. 先来先服务(FCFS)先来先服务是最简单的作业调度算法之一,它按照作业到达的先后顺序来进行调度。

当一个作业到达系统后,系统会将其放入就绪队列,然后按照先来先服务的原则,依次执行队列中的作业。

FCFS算法的优点是实现简单、公平性好,但缺点也非常明显。

由于该算法没有考虑作业的执行时间,因此可能导致长作业等待时间过长,影响系统的响应时间和吞吐量。

2. 短作业优先(SJF)短作业优先算法是一种非抢占式作业调度算法,它会根据作业的执行时间来进行调度。

当一个作业到达系统后,系统会根据其执行时间与就绪队列中其他作业的执行时间进行比较,选取执行时间最短的作业进行执行。

SJF算法的优点是能够最大程度地减少平均等待时间,提高系统的响应速度和吞吐量。

但这种算法也存在缺陷,即当有长作业不断地进入系统时,可能导致短作业一直得不到执行,进而影响系统的公平性。

3. 最高响应比优先(HRRN)最高响应比优先算法是一种动态优先级调度算法,它根据作业的响应比来进行调度。

作业的响应比定义为(等待时间+服务时间)/ 服务时间,响应比越高的作业被优先调度执行。

HRRN算法的优点是能够最大程度地提高系统的响应速度,同时保持较高的公平性。

但由于需要不断地计算和更新作业的响应比,因此算法的复杂度较高。

4. 优先级调度优先级调度算法是一种静态优先级调度算法,它根据作业的优先级来进行调度。

每个作业在进入系统时就会被赋予一个优先级,系统会按照作业的优先级来决定执行顺序。

操作系统中常用作业调度算法的分析

操作系统中常用作业调度算法的分析

操作系统中常用作业调度算法的分析作业调度是操作系统中的一个重要组成部分,它负责对待执行的作业进行排队和调度,以最大化系统资源的利用效率、满足用户需求、保证系统稳定性等目标。

常见的作业调度算法有先来先服务(FCFS)、最短作业优先(SJF)、优先级调度、时间片轮转(RR)等,接下来我们分别对这几种算法进行分析。

1. FCFS调度算法先来先服务调度算法是操作系统中最简单的一种调度算法,也是最常用的一种调度算法。

它的处理方式是根据提交时间顺序,按照FIFO的顺序进行调度。

该算法的优点是简单易用,而且很容易实现。

同时,对于大多数情况下,该算法的资源分配相对公平。

但是,该算法存在着一些问题。

当一个作业的执行时间较长时,会大大降低系统的吞吐量,严重影响系统的效率。

因此,在实际应用中,该算法往往不能满足对作业的实时响应和高效完成的要求。

最短作业优先调度算法是一种非抢占式调度算法,它将作业按照其需要执行的时间长短大小进行排序,然后从执行时间最短的作业开始调度。

在实际应用中,该算法可以减少平均等待时间和平均周转时间,提高系统的效率和性能。

但是,该算法有个致命的缺点——它无法预测作业的执行时间。

如果一个长作业被排在了等待队列的前面,那么所有后续的短作业都要等待非常长的时间,这可能导致饥饿现象的出现。

3. 优先级调度算法优先调度算法是一种根据作业优先级大小进行调度的算法,可以根据作业的重要程度或紧急程度来设置不同的优先级。

该算法可以提高系统的响应速度和稳定性,满足系统特定的需求。

但是,该算法也存在着一些问题。

如果一个作业的优先级太高,那么其余的作业可能会一直处于等待状态,这种情况也会导致饥饿现象的出现。

此外,该算法的优先级设置需要有一定的经验和技巧,否则可能会对系统的性能产生不良影响。

4. 时间片轮转算法时间片轮转算法是一种循环调度算法,它将CPU的时间分成多个固定大小的时间片,然后在每个时间片内轮流执行等待队列中的作业,以便平均分配CPU资源。

操作系统四种调度算法

操作系统四种调度算法

操作系统四种调度算法操作系统对进程的调度一般上有四种常见的算法。

下面由店铺为大家整理了操作系统的四种调度算法的相关知识,希望对大家有帮助!操作系统四重调度算法之一、先来先服务调度算法先来先服务(FCFS)调度算法是一种最简单的调度算法,该算法既可用于作业调度,也可用于进程调度。

当在作业调度中采用该算法时,每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业,将它们调入内存,为它们分配资源、创建进程,然后放入就绪队列。

在进程调度中采用FCFS算法时,则每次调度是从就绪队列中选择一个最先进入该队列的进程,为之分配处理机,使之投入运行。

该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。

操作系统四重调度算法之二、短作业(进程)优先调度算法短作业(进程)优先调度算法SJ(P)F,是指对短作业或短进程优先调度的算法。

它们可以分别用于作业调度和进程调度。

短作业优先(SJF)的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业,将它们调入内存运行。

而短进程优先(SPF)调度算法则是从就绪队列中选出一个估计运行时间最短的进程,将处理机分配给它,使它立即执行并一直执行到完成,或发生某事件而被阻塞放弃处理机时再重新调度。

操作系统四重调度算法之三、高优先权优先调度算法1.优先权调度算法的类型为了照顾紧迫型作业,使之在进入系统后便获得优先处理,引入了最高优先权优先(FPF)调度算法。

此算法常被用于批处理系统中,作为作业调度算法,也作为多种操作系统中的进程调度算法,还可用于实时系统中。

当把该算法用于作业调度时,系统将从后备队列中选择若干个优先权最高的作业装入内存。

当用于进程调度时,该算法是把处理机分配给就绪队列中优先权最高的进程,这时,又可进一步把该算法分成如下两种。

1) 非抢占式优先权算法在这种方式下,系统一旦把处理机分配给就绪队列中优先权最高的进程后,该进程便一直执行下去,直至完成;或因发生某事件使该进程放弃处理机时,系统方可再将处理机重新分配给另一优先权最高的进程。

操作系统常用调度算法

操作系统常用调度算法

操作系统常⽤调度算法在操作系统中存在多种调度算法,其中有的调度算法适⽤于作业调度,有的调度算法适⽤于进程调度,有的调度算法两者都适⽤。

下⾯介绍⼏种常⽤的调度算法。

先来先服务(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繁忙型作业。

几种操作系统调度算法

几种操作系统调度算法

几种操作系统调度算法操作系统调度算法是操作系统中用于确定进程执行的顺序和优先级的一种方法。

不同的调度算法有不同的优缺点,适用于不同的场景和需求。

下面将介绍几种常见的操作系统调度算法:1.先来先服务(FCFS)调度算法:先来先服务调度算法是最简单的调度算法之一、按照进程到达的顺序进行调度,首先到达的进程先执行,在CPU空闲时执行下一个进程。

这种算法实现简单,并且公平。

但是,由于没有考虑进程的执行时间,可能会导致长作业时间的进程占用CPU资源较长时间,从而影响其他进程的响应时间。

2.短作业优先(SJF)调度算法:短作业优先调度算法是根据进程的执行时间进行排序,并按照执行时间最短的进程优先执行。

这种算法可以减少平均等待时间,提高系统的吞吐量。

然而,对于长作业时间的进程来说,等待时间会相对较长。

3.优先级调度算法:优先级调度算法是根据每个进程的优先级来决定执行顺序的。

优先级可以由用户设置或者是根据进程的重要性、紧迫程度等因素自动确定。

具有较高优先级的进程将具有更高的执行优先级。

这种算法可以根据不同情况进行灵活调度,但是如果不恰当地设置优先级,可能会导致低优先级的进程长时间等待。

4.时间片轮转(RR)调度算法:时间片轮转调度算法将一个固定的时间片分配给每个进程,当一个进程的时间片用完时,将该进程挂起,调度下一个进程运行。

这种算法可以确保每个进程获得一定的CPU时间,提高系统的公平性和响应速度。

但是,对于长时间运行的进程来说,可能会引起频繁的上下文切换,导致额外的开销。

5.多级反馈队列(MFQ)调度算法:多级反馈队列调度算法将进程队列划分为多个优先级队列,每个队列有不同的时间片大小和优先级。

新到达的进程被插入到最高优先级队列,如果进程在时间片内没有完成,则被移到下一个较低优先级队列。

这种算法可以根据进程的执行表现自动调整优先级和时间片,更好地适应动态变化的环境。

以上是几种常见的操作系统调度算法,每种算法都有其优缺点和适用场景。

操作系统短作业优先调度算法

操作系统短作业优先调度算法

操作系统短作业优先调度算法操作系统的短作业优先调度算法(Shortest Job First Scheduling,简称SJF)是一种用于进程调度的算法。

它的优势在于能够最小化平均等待时间,并且适用于批处理系统。

在本文中,我们将对SJF算法进行详细解释,并讨论其优缺点以及适用场景。

SJF算法的基本思想是优先选择估计完成时间最短的任务进行调度。

在该算法中,每个进程都与一个估计运行时间相关联,估计时间越短的进程将被优先调度执行。

通常情况下,进程的估计运行时间由之前的执行时间或者进程已经消耗的CPU周期数量来确定。

SJF算法可以分为两种类型:非抢占式和抢占式。

在非抢占式SJF中,一旦进程开始执行,它将一直运行直到完成。

而在抢占式SJF中,如果一个新进程的估计时间更短,则当前正在执行的进程将被暂停,并且将被新进程替换。

具体来说,SJF算法的执行步骤如下:1.从就绪队列中选择估计运行时间最短的进程。

2.若操作系统支持抢占式调度,则如果有一个新进程的估计时间更短,那么当前正在执行的进程将被抢占。

3.执行选定的进程,并更新进程的状态和估计运行时间。

4.如果进程未完成,则将其放回就绪队列,并重复第1步。

5.如果所有进程都已完成,则算法结束。

SJF调度算法的优点在于能够最小化平均等待时间,因为估计时间最短的进程将会先执行,而不会被长时间的进程阻塞。

这使得系统能够更高效地利用CPU资源,提高运行效率。

然而,SJF算法也有一些缺点。

首先,它要求对进程的估计运行时间有准确的预测,但在实际情况中,很难准确预测每个进程的运行时间。

其次,SJF算法对于长时间的进程可能会产生不公平现象,因为这些进程可能需要等待很长时间才能得到执行。

此外,SJF算法还有一些适用场景。

它特别适合用于批处理系统或长时间运行的作业,其中有多个进程需要按照最短运行时间进行调度。

这样可以确保任务能够快速完成并提高整体系统效率。

综上所述,SJF算法是一种用于进程调度的短作业优先调度算法。

计算机系统中的操作系统调度算法分析

计算机系统中的操作系统调度算法分析

计算机系统中的操作系统调度算法分析操作系统是指负责管理计算机硬件和软件资源,提供服务和接口给用户和应用程序的一个软件系统。

在操作系统中,调度算法对于资源的分配和使用起到了至关重要的作用。

本文将就计算机系统中的操作系统调度算法进行分析。

一、调度算法分类操作系统调度算法可分为以下几种:1.先来先服务算法(FCFS)FCFS算法是指按照任务的到达时间顺序进行调度,任务先到达的先被处理。

该算法实现简单,但当优先级相同的任务比较多时容易出现饥饿现象。

2.最短作业优先算法(SJF)SJF算法是指在就绪队列中选择执行时间最短的任务进行处理。

该算法会导致短作业得到优先处理,但是如果长作业一直没有执行完成,就可能出现饥饿现象。

3.优先级调度算法(PS)PS算法是根据不同的任务设定不同的优先级,优先级高的任务具有更高的调度优先级。

该算法会导致优先级高的任务得到优先处理,但当优先级低的任务过多时会出现饥饿现象。

4.时间片轮转算法(RR)RR算法是指将CPU的使用时间按照时间片分配给正在就绪队列中等待的任务,每个任务得到固定的时间。

当时间片用完时,当前任务会被挂起,让主调度程序去调度下一个任务。

该算法可以避免饥饿现象,但是需要设置合适的时间片大小。

二、调度算法应用分析不同的调度算法在不同的场合下具有不同的优缺点,应该根据具体情况选择合适的算法。

1.对于长作业环境,应选择SJF算法。

SJF算法适用于长作业环境下,具有较好的平均等待时间和平均周转时间。

2.对于突发性任务环境,应选择RR算法。

RR算法适用于突发性任务,在较短的时间内完成任务,降低响应时间。

3.对于多级队列环境,应选择多级反馈队列算法。

多级反馈队列算法可以根据不同的任务类型、优先级和资源需求将就绪队列分成多个队列,并设置不同的时间片,有效避免饥饿现象。

三、调度算法改进分析在实际应用中,操作系统调度算法面临着一系列的问题,需要进行不断地改进和优化。

以下是几种调度算法的改进措施:1.最短剩余时间优先算法(SRT)SRT算法是SJF算法的改进,它考虑到了长作业对短作业的影响,对于已经进入执行状态的任务进行优先调度。

操作系统调度算法

操作系统调度算法

操作系统调度算法1.先来先服务(FCFS)调度算法:先来先服务调度算法是最简单的调度算法之一、按照任务到达的先后顺序进行调度,先来的任务先得到执行,直到完成或阻塞。

该算法不考虑任务的执行时间,可能导致短任务等待时间过长,产生“饥饿”现象。

2.最短作业优先(SJF)调度算法:最短作业优先调度算法在任务到达时根据任务所需执行时间进行排序,选择执行时间最短的任务。

该算法可以最小化平均等待时间和周转时间,但需要完全了解任务的执行时间,对于无法准确预测执行时间的情况效果较差。

3.优先级调度算法:优先级调度算法为每个任务分配一个优先级,按照优先级从高到低进行调度。

常见的优先级调度算法有静态优先级调度和动态优先级调度。

静态优先级调度在任务到达时即确定优先级,而动态优先级调度可以根据任务的实时状态动态调整优先级。

优先级调度算法需要合理设置优先级,避免产生“饥饿”现象。

4.时间片轮转(RR)调度算法:时间片轮转调度算法将CPU时间划分为一个个固定长度的时间片,任务按照顺序分配时间片,如果任务在一个时间片内无法完成,则将其放入就绪队列的末尾,继续执行下一个任务。

时间片轮转调度算法可以降低响应时间和提高交互性,但对于长时间的任务可能会造成不必要的上下文切换。

5.多级反馈队列调度算法:多级反馈队列调度算法将任务分为多个不同优先级的队列,每个队列按照FCFS或RR算法进行调度。

任务在较高优先级队列等待一定时间后,如果未能完成,则降低优先级,放入更低优先级队列继续执行。

多级反馈队列调度算法可以适应不同任务类型和执行时间。

总结来说,不同的调度算法适用于不同的场景和需求。

先来先服务调度算法简单直观,但可能存在任务等待时间过长的问题;最短作业优先调度算法可以最小化任务的平均等待时间和周转时间,但需要准确预测任务的执行时间;优先级调度算法可以根据任务的重要性进行优先级调度,但需要合理设置优先级;时间片轮转调度算法可以提高交互性,但可能造成不必要的上下文切换;多级反馈队列调度算法可以适应不同任务类型和执行时间,但需要合理设置队列的优先级和时间片长度。

操作系统调度算法

操作系统调度算法

操作系统调度算法操作系统调度算法是指在多任务操作系统中决定进程执行顺序的一种方法。

不同的调度算法会对系统的性能、响应时间、吞吐量等方面产生不同的影响。

在本文中,我们将介绍几种常见的操作系统调度算法,并讨论它们的优势和劣势。

一、先来先服务调度算法(First-Come, First-Served)先来先服务调度算法是最简单的一种调度算法,它按照进程到达的先后顺序进行调度。

当一个进程进入就绪队列后,CPU会被分配给它,进程会一直运行直到完成或者主动放弃CPU。

这种算法的优点是实现简单,公平性好,适用于长作业。

然而,由于没有考虑进程的执行时间,可能会导致长作业占用CPU时间过长,影响其他短作业的响应时间。

二、最短作业优先调度算法(Shortest Job First)最短作业优先调度算法是根据进程的执行时间来决定优先级的调度算法。

在就绪队列中,选择估计执行时间最短的进程先执行。

这种算法的优点是可以最大程度地减少平均等待时间和周转时间,提高系统的吞吐量。

然而,由于无法准确预测进程的执行时间,可能会导致长作业等待时间过长,产生“饥饿”现象。

三、时间片轮转调度算法(Round Robin)时间片轮转调度算法是一种分时调度算法,在这种算法中,每个进程被分配一个固定的时间片,当时间片用完后,CPU被剥夺,分配给下一个等待执行的进程。

这种算法的优点是公平性好,可以保证所有进程在一段时间内都能获得CPU时间。

然而,如果时间片设置得过小,可能会导致频繁的上下文切换,降低系统的效率;如果时间片设置得过大,可能会导致长作业等待时间过长。

四、优先级调度算法(Priority Scheduling)优先级调度算法是根据进程的优先级来决定调度顺序的算法。

每个进程都被分配一个优先级,高优先级的进程先执行。

这种算法的优点是可以根据不同的需求调整进程的优先级,保证紧急任务得到及时响应。

然而,如果优先级设置不当,可能会导致低优先级进程长时间等待,产生“饥饿”现象。

操作系统作业调度算法

操作系统作业调度算法

操作系统作业调度算法操作系统作业调度算法是操作系统中的一个重要概念,它决定了在多道程序环境下,各个作业的执行顺序和分配时间。

正确选择合适的调度算法可以提高系统的效率和性能,保证作业能够按时完成。

本文将介绍几种常见的作业调度算法,包括先来先服务(FCFS)、短作业优先(SJF)、最高响应比优先(HRRN)和轮转法(RR)。

先来先服务(FCFS)调度算法是最简单的一种算法,它按照作业到达的先后顺序进行调度。

当一个作业到达后,如果系统中没有其他作业在执行,则该作业立即执行;如果有其他作业在执行,则该作业会进入就绪队列等待。

FCFS算法的优点是实现简单,但是它容易导致长作业等待时间过长,影响系统的响应时间。

短作业优先(SJF)调度算法是根据作业的执行时间来进行调度的。

当一个作业到达后,系统会比较该作业的执行时间与当前正在执行的作业的执行时间,如果该作业的执行时间更短,则该作业会被优先执行。

SJF算法的优点是能够减少作业的等待时间,提高系统的响应速度,但是它需要预先知道每个作业的执行时间,对于实时系统来说并不适用。

最高响应比优先(HRRN)调度算法是根据作业的等待时间和执行时间的比值来进行调度的。

当一个作业到达后,系统会计算该作业的响应比,响应比越高,优先级越高,该作业会被优先执行。

响应比的计算公式为(等待时间+执行时间)/ 执行时间。

HRRN算法的优点是能够兼顾作业的等待时间和执行时间,提高系统的整体性能,但是它需要不断地重新计算作业的响应比,增加了调度算法的复杂度。

轮转法(RR)调度算法是将系统的处理时间分为若干个时间片,每个时间片内一个作业可以执行的时间是固定的,当一个作业到达后,系统会将其放入就绪队列的末尾,并在当前时间片内执行该作业。

当一个时间片结束后,如果作业还没有执行完,系统会将其放回就绪队列的末尾,等待下一轮的调度。

轮转法算法的优点是能够公平地分配CPU时间,避免了长作业的等待时间过长,但是它可能导致一些短作业的响应时间较长。

操作系统各种调度算法

操作系统各种调度算法

操作系统各种调度算法操作系统的调度算法是操作系统中的重要组成部分,它决定了进程在CPU上的执行顺序和调度策略。

不同的调度算法应用于不同的场景和需求,目的是提高CPU利用率、降低响应时间、提高吞吐量等。

本文将介绍几种常见的调度算法,包括先来先服务调度算法(FCFS)、最短作业优先调度算法(SJF)、时间片轮转调度算法(RR)和多级反馈队列调度算法(MFQ)。

先来先服务调度算法(FCFS)是最简单的调度算法之一,该算法按照进程到达的先后顺序分配CPU资源。

当一个进程在CPU上执行时,其他进程需要等待,直到该进程完成。

FCFS调度算法具有易于实现和公平性的优点,但是由于没有考虑进程的执行时间,可能导致长作业的久等和短作业的饥饿问题。

最短作业优先调度算法(SJF)根据进程的预计执行时间来调度。

该算法假设可以获得每个进程的执行时间,并选择执行时间最短的进程执行。

SJF调度算法可以最小化平均等待时间和响应时间,但是由于无法准确预测进程的执行时间,可能导致长作业的饥饿问题。

时间片轮转调度算法(RR)将CPU时间切分成固定长度的时间片,每个进程在一个时间片中执行。

当一个进程的时间片用完后,系统将该进程重新加入到就绪队列的末尾,让其他就绪进程获得CPU执行。

RR调度算法能够保证每个进程都能获得一定的CPU时间,但是当进程的执行时间过长时,可能需要频繁的上下文切换,导致系统开销增加。

多级反馈队列调度算法(MFQ)是一种结合了FCFS和RR的调度算法。

该算法将就绪队列划分成多个队列,每个队列有不同的优先级,并且每个队列采用RR调度算法。

进程首先进入高优先级队列,如果时间片用完仍未完成,则降低优先级进入下一级队列,直到最低优先级队列。

此时,进程将拥有更长的时间片并能够执行较长时间。

MFQ调度算法兼顾了短作业的优先执行和长作业的公平性,但是需要根据实际情况设置多个队列和时间片长度,较为复杂。

除了以上介绍的几种调度算法,还有其他一些调度算法可供选择,如最高响应比优先调度算法(HRRN)、最早截止时间优先调度算法(EDF)等。

操作系统各种调度算法

操作系统各种调度算法

操作系统各种调度算法⼀、批处理作业调度算法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,该进程进⼊就绪队列,等待下⼀次调度,同时,进程调度⼜去选择就绪队列中的⼀个进程,分配给它⼀个时间⽚,以投⼊运⾏。

计算机操作系统调度算法

计算机操作系统调度算法

计算机操作系统调度算法计算机操作系统将任务分成多个进程,并将它们分配给CPU 以便执行。

当多个进程在互相竞争CPU时,调度算法将帮助操作系统决定哪个进程将被运行。

调度算法可以提高系统的性能和响应速度,同时还能减少资源浪费。

1.先进先出(FIFO)调度算法先进先出调度算法是最简单的算法。

该算法按照每个进程进入系统的顺序依次分配CPU时间,并等待该进程完成后再运行下一个进程。

FIFO算法很容易实现,但是它的缺点是没有考虑进程的优先级和执行时间。

这意味着,长时间运行的进程可能会阻塞短时间运行的进程,并且平均等待时间也无法减少。

2.最短作业优先(SJF)调度算法最短作业优先调度算法是一个基于进程执行时间的预测算法。

该算法会优先运行预计执行时间最短的进程,因此平均等待时间会更短。

但该算法有一个问题:如果存在长时间运行的进程,那么它们可能永远无法运行,这会导致一些进程一直处于等待状态。

3.优先级调度算法优先级调度算法通过为每个进程分配不同的优先级,来确定哪个进程应该先运行。

预设的进程优先级可能基于进程的类型、缺陷、执行时间和操作系统要求等因素。

4.时间片轮转(RR)调度算法时间片轮转调度算法是一种基于时间分配CPU时间的算法。

该算法为每个进程分配一个小的时间片,如10ms或50ms,并按照时间片依次运行进程。

如果进程无法在一个时间片内完成,则进程被送到队列的末尾。

时间片轮转调度算法可以避免长时间运行的进程阻塞短时间运行的进程,并提高平均等待时间。

5.多级反馈队列(MFQ)调度算法多级反馈队列调度算法是一种结合了以上几种调度算法的算法。

它将进程分配到几个队列中,每个队列有不同的优先级和时间片。

优先级高,时间片较长的队列中,会先运行高优先级的进程。

如果进程超出了它被分配的时间,并在该队列中一直等待,进程会在等待时间超过设定时间限制后继续移动到更低优先级的队列。

总结不同的任务需要不同的调度算法。

例如,对于短时间运行的进程,SJF算法可能表现最好,而RR算法适用于需要等待时间短的任务。

计算机操作系统的调度算法

计算机操作系统的调度算法

计算机操作系统的调度算法随着计算机技术的飞速发展,操作系统扮演着越来越重要的角色。

操作系统是计算机软件的一部分,负责管理计算机的各种资源,其中之一就是进程的调度算法。

调度算法是操作系统中负责决定进程执行顺序的重要组成部分。

它可以根据某些策略和规则,合理分配计算机的处理器资源,提高系统的性能和效率。

下面将为大家介绍一些常见的计算机操作系统调度算法。

1. 先来先服务(FCFS)调度算法先来先服务是最简单、最直观的调度算法之一。

按照进程到达的顺序依次分配处理器资源,无论进程的优先级和需要执行的时间。

这种算法的优点是简单易实现,但是无法适应不同种类进程的需求,容易导致长作业的执行时间过长而影响其他进程的运行。

2. 短作业优先(SJF)调度算法短作业优先调度算法是根据进程的服务时间来进行排序,并按照时间最短的顺序分配处理器资源。

短作业优先算法可以减少平均等待时间,但会导致长作业饥饿,即长时间等待的作业无法得到执行。

3. 优先级调度算法优先级调度算法根据进程的优先级来分配处理器资源。

每个进程都有一个优先级,优先级高的进程先得到执行。

这种算法可以根据不同作业的需求进行灵活调度,但是可能导致优先级过高的进程占用过多的资源,影响其他进程的执行。

4. 时间片轮转调度算法时间片轮转是一种常见的多任务调度算法。

它将处理器的时间分成若干个时间片,每个进程在一个时间片内得到执行,然后切换到下一个进程。

时间片轮转算法可以保证公平性,每个进程都有机会得到执行,但是对于长时间的作业,可能会导致上下文切换的频繁,降低系统的效率。

5. 多级反馈队列调度算法多级反馈队列调度算法将进程按照优先级划分到不同的队列中,每个队列有不同的时间片大小。

进程按照优先级先执行高优先级队列中的作业,而低优先级的进程则进入下一个队列等待执行。

这种算法结合了优先级调度和时间片轮转调度的特点,可以有效平衡系统的性能和公平性。

6. 最短剩余时间(SRT)调度算法最短剩余时间调度算法是短作业优先调度算法的一种改进。

操作系统作业调度算法

操作系统作业调度算法

操作系统作业调度算法在计算机操作系统中,作业调度算法起着至关重要的作用。

它决定了哪些作业能够被优先处理,以及如何合理地分配系统资源,以提高整个系统的性能和效率。

让我们先来理解一下什么是作业调度。

简单来说,当有多个作业等待被处理时,操作系统需要决定哪个作业先进入处理状态,哪个作业需要等待。

这就像是在一个繁忙的餐厅,服务员需要决定先为哪桌客人上菜一样。

常见的作业调度算法有先来先服务(FCFS)、短作业优先(SJF)、优先级调度、高响应比优先调度和时间片轮转调度等。

先来先服务算法是最简单直观的一种。

它按照作业到达的先后顺序进行调度。

就好比排队买票,先到的人先买。

这种算法的优点是实现简单、公平,大家都按照先来后到的顺序。

但它也有明显的缺点,如果先到达的作业执行时间很长,后面的短作业就需要长时间等待,可能会导致系统的平均周转时间较长。

短作业优先算法则是优先处理执行时间短的作业。

这就像是在餐厅中,先为点了简单菜品的客人上菜。

它的优点是能够减少平均周转时间,提高系统的吞吐量。

但问题是,我们很难准确预知作业的执行时间,而且如果一直有更短的作业到来,长作业可能会被“饿死”。

优先级调度算法为每个作业赋予一个优先级,优先级高的作业先被处理。

这有点像医院的急诊室,病情紧急的患者优先得到治疗。

这种算法可以灵活地根据作业的重要性或紧急程度来安排处理顺序,但确定合理的优先级可能会比较困难,而且如果优先级设置不当,也可能导致一些作业长时间得不到处理。

高响应比优先调度算法综合考虑了作业的等待时间和执行时间。

响应比=(等待时间+执行时间)/执行时间。

这样既照顾了先来的作业,又不会让短作业等待太久。

它在一定程度上克服了先来先服务和短作业优先算法的缺点,但计算响应比也会增加系统的开销。

时间片轮转调度算法将 CPU 时间分成固定大小的时间片,每个作业轮流使用一个时间片。

如果作业在一个时间片内没有完成,就会被放到队列的末尾等待下一轮。

这就像是大家轮流发言,每人都有一定的时间。

操作系统作业调度算法

操作系统作业调度算法

02 作业调度基本概念
作业与作业步
作业
用户在一次计算过程中或一次事 务处理中要求计算机系统所做的 工作的集合。
作业步
作业运行过程中的相对独立部分 ,每个作业步都是一个独立的程 序,需要从外存调入内存运行。
作业状态及其转换
四种状态
提交、后备、执行和完成。
状态转换
作业从提交状态开始,经过后备状态,然后到执行状态,最后到完成状态。
调度器的类型
Linux支持多种类型的调度器,包括实时调度器、完全公平调度 器(CFS)等,以满足不同应用场景的需求。
完全公平调度器(CFS)原理及实现
CFS设计目标
时间记账与虚拟运行时间
红黑树与调度实体
进程选择与切换
CFS是Linux内核中默认的调度 器,旨在提供一个公平、高效 的CPU时间分配机制,确保所 有进程都能获得相对平等的 CPU使用权。
基于机器学习的调度算法
数据驱动
利用机器学习技术从历史数据中学习作业特征和资源 需求模式。
智能决策
基于学习到的模型,对作业进行智能分类、优先级排 序和调度决策。
自适应调整
根据系统反馈和性能评估结果,自适应地调整机器学 习模型和调度策略。
多级反馈队列调度算法
多级队列
将作业按照不同的优先级和资源需求分配到不同的队列中。
操作系统作业调度算法
目录
Contents
• 引言 • 作业调度基本概念 • 常见作业调度算法 • 调度算法性能评价 • 作业调度算法优化与改进 • 实例分析:Linux作业调度算法 • 总结与展望
01 引言
目的和背景
提高系统资源利用率
实现公平性
通过合理的作业调度算法,可以更加 高效地利用系统资源,包括CPU、内 存、I/O设备等,从而提高系统的整体 性能。

操作系统调度算法

操作系统调度算法

操作系统调度算法操作系统调度算法是操作系统中一个重要的概念,它决定了进程如何被分配和执行。

调度算法的好坏直接关系到系统的性能和用户体验。

本文将介绍几种常见的操作系统调度算法,并分析它们的特点和适用场景。

先来了解一下什么是操作系统调度算法。

操作系统中可能同时存在多个进程,而CPU只能一次执行一个进程,因此需要调度算法来确定优先级和执行顺序。

调度算法的目标一般包括提高系统吞吐量、降低响应时间、提高公平性等。

下面是几种常见的调度算法。

1. 先来先服务调度算法(FCFS)先来先服务调度算法是最简单的调度算法之一,按照进程到达的顺序进行调度。

它的优点是实现简单,公平性较好,但是可能会导致平均等待时间较长。

当一个长时间运行的进程在等待短进程结束时,会出现所谓的“饥饿”问题。

2. 短作业优先调度算法(SJF)短作业优先调度算法是按照进程运行时间长度来调度的,即运行时间短的进程优先被执行。

它的优点是平均等待时间较短,但是无法处理长进程的“饥饿”问题。

此外,该算法对进程运行时间的准确预测要求较高。

3. 时间片轮转调度算法(RR)时间片轮转调度算法是按照时间片来调度的,每个进程被分配一个固定的时间片,当时间片用完后,如果进程还未完成,则将其放入就绪队列的末尾,并将下一个进程调度到CPU上执行。

这样可以保证每个进程都有机会执行,但是如果时间片设置不合理,会出现频繁的上下文切换,导致系统开销增大。

4. 优先级调度算法优先级调度算法是根据进程的优先级来进行调度的,优先级高的进程优先执行。

优先级可以是静态的,由系统管理员或进程创建者指定,也可以是动态的,根据运行情况进行调整。

该算法存在优先级翻转和饥饿问题,需要合理设计。

以上只是简要介绍了几种常见的操作系统调度算法,实际上还有很多其他算法,如多级反馈队列调度算法、最短剩余时间优先调度算法等。

选择适合的调度算法需要根据具体的应用场景和需求来决定。

总结一下,操作系统调度算法是操作系统中一个重要的概念,它决定了进程的执行顺序和优先级。

几种操作系统调度算法

几种操作系统调度算法

几种操作系统调度算法操作系统调度算法是操作系统中的关键机制之一,用于确定进程的执行顺序和分配处理器时间片。

不同的调度算法可以根据不同的应用需求和系统性能进行选择。

下面将介绍几种常见的操作系统调度算法。

1.先来先服务(FCFS)调度算法:即按照进程到达的先后顺序进行调度。

对于短作业而言,这种算法可以保证公平性,但对于长作业而言,可能会导致等待时间过长的问题。

2.最短作业优先(SJF)调度算法:即选择执行时间最短的作业进行调度。

这种算法可以减少平均等待时间,但需要提前准确预测作业的执行时间,对于实时系统或具有多变性质的作业调度来说,这种算法可能存在不可行性。

3.优先级调度算法:为每个进程分配一个优先级,并按照优先级大小进行调度。

可以根据作业的重要程度、紧迫程度等因素来分配优先级。

优先级调度算法可以优先保证重要作业的执行,但还需要解决优先级反转、饥饿等问题。

4.时间片轮转(RR)调度算法:将处理器时间分成固定大小的时间片,每个进程在一个时间片的执行时间后被挂起,然后按照队列中的顺序进行下一个时间片的调度。

这种算法可以保证每个进程都有执行的机会,但对于长作业而言,可能会导致响应时间过长的问题。

5.最高响应比优先(HRRN)调度算法:根据作业等待时间和作业执行时间的比值来选择下一个要执行的作业。

这种算法可以根据作业的等待情况来自动调整作业的执行优先级,适用于具有多变性质的作业调度。

6.多级反馈队列(MFQ)调度算法:将进程按照优先级分成多个队列,初始时将所有进程放入第一级队列,每个队列的时间片大小逐级递增。

当进程在其中一级队列用完时间片后,如果仍然有剩余时间,则将进程移到下一级队列。

这种算法可以根据作业的执行情况进行动态调整,适用于提高系统吞吐量和减少响应时间。

以上是几种常见的操作系统调度算法,每种算法都有其优点和缺点,具体选择哪种算法需要根据系统的需求和特点进行综合考虑。

为了提高系统性能和用户体验,操作系统调度算法的研究与优化一直是操作系统领域的重要研究方向。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

操作系统上机测试作业调度算法算法一、实验目的和要求(供参考)1.掌握作业调度功能和调度程序常用算法。

2.掌握利用C语言设计实现不同调度策略的作业调度算法。

3.验证不同作业调度算法对性能的影响。

二、实验环境(供参考)1.知识准备:学过进程管理、作业管理、处理机调度等章节的内容。

2.开发环境与工具:硬件平台——个人计算机。

软件平台——C语言开发环境。

三、实验内容用“先来先服务(FCFS)”算法和“最短作业优先(SJF)”算法模拟作业调度。

要求:按作业的到达顺序输入各作业需要的运行时间,按算法调度输出平均周转时间。

例如(FCFS),输入:8(到达时间0),5(到达时间2),7(到达时间3),1(到达时间6)J1 J2 J3 J40 8 13 20 21输出:aver=(8+(13-2)+(20-3)+(21-6))/4=51/4例如(SJF),输入:8(到达时间0),5(到达时间2),7(到达时间3),1(到达时间6)J1 J4 J2 J30 8 9 14 21输出:aver=(8+(9-6)+(14-2)+(21-3))/4=42/4注:输入的格式任意,只要输出平均周转时间即可。

四、代码(带注释)1、先来先服务实验结果(截图呈现)代码:#include <iostream>using namespace std;class Fcfs{private:int num[10]; //作业编号double arriveTime[10]; //到达时间double startTime[10]; //开始时间,进内存时间double workTime[10]; //工作时间double finishTime[10]; //完成时间double cirTime[10]; //存放每一个作业的周转时间//double freeTime[10]; //上一个作业已结束,但下一个作业还未到,存放这一段空闲时间public:Fcfs(int n) //n为作业数目{cout<<"默认第一个作业的到达时间为0。

"<<endl;for(int i=0;i<n;i++){num[i]=i+1; //给作业编号cout<<"第"<<num[i]<<"个作业:"<<endl;cout<<"请输入该作业的到达时间:";cin>>arriveTime[i];if(i==0)arriveTime[i]=0; //默认第一个作业的到达时间为0cout<<"请输入该作业的执行时间:";cin>>workTime[i];if(i==0){startTime[i]=0;finishTime[i]=workTime[i];//freeTime[i]=0;}else if(arriveTime[i]<=finishTime[i-1]) //如果后一个作业已到,而前一个作业未结束{startTime[i]=finishTime[i-1]; //则后一个作业的开始时间为上一个作业的结束时间finishTime[i]=startTime[i]+workTime[i];//freeTime[i]=0; //前一个一结束就开始工作,没有空闲时间}else if(arriveTime[i]>finishTime[i-1]){//freeTime[i]=arriveTime[i]-finishTime[i-1];//计算空闲时间,前一个作业已完成,但后一个作业还没到,中间空闲时间startTime[i]=arriveTime[i]; //由于来的时候前一个作业已完成,则该作业的开始时间即为它的到达时间finishTime[i]=startTime[i]+workTime[i];}cirTime[i]=finishTime[i]-arriveTime[i];}}//计算平均周转时间double getAverageCir(int n) //n为作业数{double averageCir,sumCir=0;for(int i=0;i<n;i++)sumCir+=cirTime[i];averageCir=sumCir/n;return averageCir;}//打印输出void print(int n) //n为作业数{cout<<"num\t"<<"arrive\t"<<"start\t"<<"work\t"<<"finish\t"<<"cir\t"<<endl;for(int i=0;i<n;i++){cout<<num[i]<<"\t"<<arriveTime[i]<<"\t"<<startTime[i]<<"\t"<<workTime[i]<<"\t"<<finish Time[i]<<"\t"<<cirTime[i]<<"\t"<<endl;}cout<<endl;cout<<"平均周转时间:"<<getAverageCir(n)<<endl;}};int main(){int n; //n为作业数目cout<<"请输入作业数目:";cin>>n;Fcfs f=Fcfs(n);f.print(n);return 0;}2.短作业优先代码:#include <iostream>using namespace std;class SJF{private:int num[10]; //作业编号double arriveTime[10]; //到达时间double startTime[10]; //开始时间,进内存时间double workTime[10]; //工作时间double finishTime[10]; //完成时间double cirTime[10]; //存放每一个作业的周转时间public:SJF(int n) //n为作业数目{int i;cout<<"默认第一个作业的到达时间为0。

"<<endl;for(i=0;i<n;i++){num[i]=i+1; //给作业编号cout<<"第"<<num[i]<<"个作业:"<<endl;cout<<"请输入该作业的到达时间:";cin>>arriveTime[i];if(i==0)arriveTime[i]=0; //默认第一个作业的到达时间为0cout<<"请输入该作业的执行时间:";cin>>workTime[i];if(i==0){startTime[i]=0;finishTime[i]=workTime[i];cirTime[i]=finishTime[i]-arriveTime[i];}else //排序{for(int j=1;j<i;j++) //i=当前作业数目-1,这里不能用num[i]表示当前作业数起泡排序法{for(int k=1;k<=i-j;k++)if(workTime[k]>workTime[k+1]){double temp;temp=num[k];num[k]=num[k+1];num[k+1]=temp;temp=arriveTime[k];arriveTime[k]=arriveTime[k+1];arriveTime[k+1]=temp;temp=workTime[k];workTime[k]=workTime[k+1];workTime[k+1]=temp;}}}}for(i=1;i<n;i++) //排序后计算各作业的开始、结束、周转时间{startTime[i]=finishTime[i-1];finishTime[i]=startTime[i]+workTime[i];cirTime[i]=finishTime[i]-arriveTime[i];}}//计算平均周转时间double getAverageCir(int n) //n为作业数{double averageCir,sumCir=0;for(int i=0;i<n;i++)sumCir+=cirTime[i];averageCir=sumCir/n;return averageCir;}//打印输出void print(int n) //n为作业数{cout<<"num\t"<<"arrive\t"<<"start\t"<<"work\t"<<"finish\t"<<"cir\t"<<endl;for(int i=0;i<n;i++){cout<<num[i]<<"\t"<<arriveTime[i]<<"\t"<<startTime[i]<<"\t"<<workTime[i]<<"\t"<<finish Time[i]<<"\t"<<cirTime[i]<<"\t"<<endl;}cout<<endl;cout<<"平均周转时间:"<<getAverageCir(n)<<endl;}};int main(){cout<<"-----短作业优先-----"<<endl;int n; //n为作业数目cout<<"请输入作业数目:";cin>>n;SJF f=SJF(n);f.print(n);return 0;}。

相关文档
最新文档