各类作业调度算法

用于作业调度的算法作业调度是计算机操作系统中的一个重要概念，它指的是在多个进程同时运行时，如何合理地分配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算法在执行过程中会动态地检测作业的执行时间，一旦有更短的作业到达，就会抢占当前的作业，提高了系统的性能。

总的来说，先来先服务算法和短作业算法都是作业调度中常用的算法。

在实际应用中，可以根据具体情况选择合适的算法，或者结合多种算法来获取更好的调度效果。

作业调度算法的选择对于系统的性能和资源利用率具有重要的影响，需要根据实际需求进行综合权衡。

作业调度算法先来先服务调度算法:按作业到达系统的先后次序进行调度.(算法容易实现，效率较低)短作业优先调度算法:从作业的后备队列中挑选运行时间最短的作业作为下一个调度运行的对象.（没考虑长作业的利益）使用短作业优先调算法，执行如下：作业的调度顺序：1、4、3、2作业号提交时间执行时间开始时间完成时间周转时间带权周转时间1 10.0 2.0 10.0 12.0 2.0 1.02 10.2 1.0 12.8 13.8 3.6 3.63 10.4 0.5 12.3 12.8 2.4 4.84 10.5 0.3 12.0 12.3 1.8 6.0平均周转时间T=2.45平均带转周转时间W=3.85采用先来先服务调度算法，执行如下：作业号提交时间执行时间开始时间完成时间周转时间带权周转时间1 10.0 2.0 10.0 12.0 2.0 1.02 10.2 1.0 12.0 13.0 2.8 2.83 10.4 0.5 13.0 13.5 3.1 6.24 10.5 0.3 13.5 13.8 3.3 11平均周转时间T=2.8平均带转周转时间W=5.25采用响应比高者优先调度算法，执行如下：调度顺序：1、4、3、2作业号提交时间执行时间开始时间完成时间周转时间带权周转时间1 10.0 2.0 10.0 12.0 2.0 1.02 10.2 1.0 12.8 13.8 3.6 3.63 10.4 0.5 12.3 12.8 2.4 4.84 10.5 0.3 12.0 12.3 1.8 6第一次响应比：r2=1+（12.0-10.2）/1.0=2.8r3=1+(12.0-10.4)/0.5=4.2r4=1+(12.0-10.5)/0.3=6第二次响应比：r2=1+(12.3-10.2)/1.0=3.1r3=1+(12.3-10.4)/0.5=4.8平均周转时间T=(2.0+3.6+2.4+1.8)/4=2.45平均带转周转时间W=3.851.响应比高者优先调度算法定义如下:响应比=作业响应/运行时间的估计值其中,响应时间为作业进入系统后的等待时间加上估计的运行时间.响应比=1+作业等待时间/运行时间的估计值响应比高者优先调度算法,就是在每次调度作业运行时,先计算后备作业队列中每个作业的响应比,然后挑选响应比最高者投入运行.响应比高者优先调度算法，执行如下：调度顺序：1、3、2、4作业号提交时间执行时间开始时间完成时间周转时间带权周转时间1 8.0 2.0 8.0 10.0 2.0 1.02 8.3 0.5 10.1 10.6 2.3 4.63 8.5 0.1 10.0 10.1 1.6 16.04 9.0 0.4 10.6 11.0 2.0 5.0第一次响应比：r2=1+(10.0-8.3)/0.5=4.4r3=1+(10.0-8.5)/0.1=16r4=1+(10.0-9.0)/0.4=3.5第二次响应比：r2=1+(10.1-8.3)/0.5=4.6r4=1+(10.1-9.0)/0.4=3.75平均周转时间T=1.975平均带转周转时间W=6.65作业号提交时间执行时间开始时间完成时间周转时间带权周转时间1 8.0 2.0 8.0 10.0 2.0 1.02 8.3 0.5 10.1 10.6 2.3 4.63 8.5 0.1 10.0 10.1 1.6 16.04 9.0 0.4 10.6 11.0 2.0 5.0例下表给出作业1、2、3的到达时间和运行时间,采用短作业优先/先来先服务/响应比高者优先调度算法,试问平均周转时间各为多少?。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

处理机调度的常用算法包括以下几种：
1. 先来先服务调度算法（FCFS，First Come First Service）：这是一种最简单的调度算法，按先后顺序进行调度。

既可用于作业调度，也可用于进程调度。

2. 短作业优先调度算法（SJF/SPF，Shortest Job First）：该算法根据作业长短进行调度，有利于短作业（进程）的完成。

3. 高响应比优先调度算法（HRRN，Highest Response Raito Next）：该算法综合考虑了作业长短和等待时间，能够适用于短作业较多的批处理系统中，但长作业的运行可能得不到保证。

4. 基于时间片的轮转调度算法（RR，Round Robin）：该算法将系统中所有的就绪进程按照FCFS原则，排成一个队列。

每次调度时将CPU 分派给队首进程，让其执行一个时间片。

时间片的长度从几个ms到几百ms。

在一个时间片结束时，发生时钟中断。

调度程序据此暂停当前进程的执行，将其送到就绪队列的末尾，并通过上下文切换执行当前就绪的队首进程。

进程阻塞情况发生时，未用完时间片也要出让CPU。

这些算法各有优缺点，需要根据实际应用场景选择合适的算法。

操作系统中常用作业调度算法的分析操作系统中的作业调度算法是指决定在多道程序环境下，操作系统按照何种顺序来调度各个作业执行的一种算法。

常见的作业调度算法有先来先服务（FCFS）、最短作业优先（SJF）、最高响应比优先（HRRN）、轮转法（RR）等。

这些算法在实际应用中各有优劣，下面将对它们进行详细分析。

先来先服务（FCFS）算法是最简单的作业调度算法，即按照作业进入队列的先后顺序进行调度。

FCFS算法简单直观，但是当一个长作业在队列前面时，会导致等待时间长，影响其他短作业的响应时间。

最短作业优先（SJF）算法是根据作业的执行时间长度进行排序，短作业先执行。

SJF 算法的优点是能够减少短作业的等待时间和周转时间，提高系统的吞吐量。

但是对于长作业来说，等待时间会变得较长。

最高响应比优先（HRRN）算法是根据作业的响应比来排序，响应比等于(等待时间+服务时间)/服务时间。

HRRN算法使得长作业能够获得更好的响应，但是在实际操作中，计算响应比需要耗费额外的时间和资源。

轮转法（RR）算法是按照时间片轮转的方式进行调度。

每个作业被分配一个时间片，当时间片用完之后，切换到下一个作业。

RR算法能够公平地分配CPU时间，避免一个作业长时间占用CPU，但是当作业的数量较多时，可能导致频繁的上下文切换，造成额外的开销。

除了以上常用的作业调度算法，还有其他一些算法，如最佳适应优先（BA）、最差适应优先（WA）、多级反馈队列（MFQ）等。

这些算法根据不同的调度策略和考虑因素而设计，可以根据具体的应用场景选择合适的算法。

作业调度算法在多道程序环境下起到了重要的作用，可以平衡系统的吞吐量和响应时间。

不同的作业调度算法有不同的优缺点，需要根据系统特点和需求进行选择。

经典的调度算法经典的调度算法一直是计算机科学中的热门话题。

这些算法旨在有效地优化计算机操作的资源使用，从而使计算机更快、更有效地处理任务。

本文将对经典的调度算法进行详细介绍，阐述其实现方法和应用场景。

第一步：了解什么是调度算法在计算机科学中，调度算法指的是为了管理并优化多个任务的同时使用计算机资源而设计的算法。

这些算法旨在最大化计算机资源的利用率，同时尽可能地减轻CPU的负载。

它们可以帮助确保任务在合理的时间内得到快速且准确的处理。

第二步：介绍不同类型的调度算法现在，让我们了解一些最常见的调度算法类型。

1. 先来先服务调度算法（FIFO）：这是最简单的调度算法之一。

在这种算法中，所有任务都按照它们提交的顺序依次执行。

它们将等待已完成的操作完成后才能以相同的顺序运行。

2. 最短作业优先调度算法（SJF）：这种算法有助于优化作业的完成时间。

这个调度算法首先运行最短的作业，从而确保它们能够尽快完成。

这种算法通常在批处理任务中使用，它可以帮助确保任务可以在合理的时间内得到处理。

3. 时间片轮转调度算法：这种算法将CPU时间的使用权分配给每个任务一定的时间片。

在一个时间片结束后，CPU的使用权转移到另一个任务上。

这种算法可以确保所有的任务都有机会平均地使用计算机资源。

第三步：讨论不同调度算法的应用不同的调度算法在不同的场景下很有用。

例如：- 简单的FIFO算法通常在基于CPU资源的多媒体应用程序中使用，例如音频和视频播放器。

- SJF算法通常用于批量处理任务，例如后台文件处理或模拟。

- 时间片轮转算法则通常用于时分复用的系统中，例如多个用户同时登录的计算机系统。

总的来说，调度算法可以对计算机的性能和资源分配产生深远的影响。

在选择特定的算法时，需要考虑一系列因素，例如任务类型、系统负载和可用的资源。

通过了解各种调度算法，可以更轻松地选择最适合自己需求的算法，从而提高计算机系统的效率。

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总结与体会通过本次实验，感觉⾃⼰对之前数据结构的算法和语法掌握得不是很好，虽然会定义结构体⽐较熟练，但是对于在程序中调⽤结构体就不太理解，导致多次出错，并通过查阅相关资料，然后不断修改，由于之前的数据结构学得不扎实，所以写代码遇到很多困难，往后要多回顾旧知识，特别是语法结构和新接触的⼏种作业调度的算法思想。