作业调度算法(先来先服务算法,短作业算法)资料讲解
用于作业调度的算法
用于作业调度的算法作业调度是计算机操作系统中的一个重要概念，它指的是在多个进程同时运行时，如何合理地分配CPU资源，使得系统能够高效地完成各项任务。
作业调度算法是实现作业调度的关键，下面将详细介绍几种常见的作业调度算法。
一、先来先服务（FCFS）算法先来先服务（FCFS）算法是最简单也是最容易实现的一种作业调度算法。
该算法按照进程到达时间的顺序依次执行，即当一个进程到达后，如果当前没有正在执行的进程，则立即执行该进程；否则将该进程加入等待队列中，并等待前面所有进程执行完毕后再进行处理。
FCFS算法优点在于简单易实现，并且保证了公平性。
但由于没有考虑到不同进程的优先级和执行时间等因素，因此可能会导致长任务等待时间过长、短任务响应时间过长等问题。
二、短作业优先（SJF）算法短作业优先（SJF）算法是一种根据作业长度进行排序的调度策略。
该算法按照各个进程需要占用CPU时间片长度进行排序后依次执行，即当一个新的进程到达时，如果其需要占用的时间片长度比当前正在执行的进程短，则立即切换到该进程进行处理，否则将该进程加入等待队列中，并等待前面所有进程执行完毕后再进行处理。
SJF算法优点在于能够最大限度地缩短作业响应时间，提高系统的吞吐量。
但由于需要预测每个进程需要占用的时间片长度，因此实现起来较为困难，并且可能会出现“饥饿”现象，即长时间等待CPU资源的进程无法得到及时处理。
三、优先级调度算法优先级调度算法是一种按照不同进程的优先级进行排序的调度策略。
该算法将每个进程赋予一个优先级值，根据优先级值高低依次执行，即当一个新的进程到达时，如果其优先级比当前正在执行的进程高，则立即切换到该进程进行处理，否则将该进程加入等待队列中，并等待前面所有优先级更高的进程执行完毕后再进行处理。
优先级调度算法可以根据不同任务类型和紧急性进行灵活调整，并且可以避免长任务等待时间过长、短任务响应时间过长等问题。
但由于可能会出现“饥饿”现象和优先级反转等问题，因此需要进行适当的优化和调整。
先来先服务FCFS和短作业优先SJF进程调度算法
先来先服务FCFS和短作业优先SJF进程调度算法
先来先服务(FCFS)算法是最简单的一种进程调度算法。
它的原则是按照作业到达的顺序，将作业分配给处理器。
当一个作业到达系统后，它将占用处理器并运行，直到完成所有的工作。
在FCFS算法中，没有考虑作业的大小或者运行时间，所有的作业都按照到达的先后顺序进行处理。
FCFS算法的优点是实现简单，没有复杂的调度信息和数据结构的支持；缺点是对于长作业或者执行时间较长的作业来说，等待时间会很长，导致响应时间较慢，同时也会降低系统的吞吐量。
短作业优先(SJF)算法是一种根据作业的执行时间进行调度的算法。
它的原则是当一个作业到达系统后，系统将根据作业的执行时间，将处理器分配给执行时间最短的作业。
在SJF算法中，系统需要对每一个作业的执行时间进行估计，然后选择执行时间最短的作业。
SJF算法的优点是能够最大限度地减少作业的等待时间，提高系统的响应速度和吞吐量；缺点是需要对作业的执行时间进行准确的估计，而这往往是比较困难的。
如果估计不准确，可能会导致执行时间较长的作业一直等待，而执行时间较短的作业得到了优先处理。
总结起来，FCFS和SJF两种进程调度算法各有优缺点。
FCFS算法简单直观，但可能导致作业的等待时间较长；而SJF算法可以最大限度地减少作业的等待时间，但需要准确地估计作业的执行时间。
在实际使用中，可以根据作业的特点和系统的需求选择适合的调度算法。
同时，也可以考虑使用其他的调度算法，如时间片轮转、优先级调度等，来满足更复杂的任务调度需求。
常用的调度算法
常用的调度算法调度算法是指操作系统中用于决定进程何时执行、何时暂停等的一种算法。
常用的调度算法包括先来先服务（FCFS）、短作业优先（SJF）、优先级调度、时间片轮转等。
下面将对这些常用的调度算法进行详细介绍。
一、先来先服务（FCFS）先来先服务是最简单的调度算法之一，它按照进程到达的顺序进行调度，即谁先到谁先执行。
这种算法容易实现，但是存在“饥饿”现象，即如果某个进程长时间等待，则其他进程可能会一直占用CPU资源，导致该进程无法得到执行。
因此，在实际应用中，FCFS很少被使用。
二、短作业优先（SJF）短作业优先是一种以作业运行时间为依据的调度算法。
它通过预测每个进程需要运行的时间，并将其按照运行时间从小到大排序，然后依次执行。
这种算法可以最大限度地减少平均等待时间和平均周转时间，并且不会出现“饥饿”现象。
但是，在实际应用中，由于很难准确预测每个进程需要运行的时间，因此SJF也存在缺陷。
如果预测不准确，那么就会出现长作业等待短作业的情况，导致长作业的等待时间变长。
三、优先级调度优先级调度是一种按照进程优先级进行调度的算法。
每个进程都有一个优先级，系统会根据进程的优先级来决定下一个要执行的进程。
通常情况下，优先级越高的进程越有可能得到CPU资源。
但是，如果某个进程的优先级一直比其他进程高，那么其他进程就会一直等待，导致“饥饿”现象。
此外，在实际应用中，由于不同进程之间的优先级差别较大，因此可能会导致低优先级的进程长时间等待。
四、时间片轮转时间片轮转是一种按照时间片进行调度的算法。
它将CPU资源划分成若干个时间片，并将每个时间片分配给一个正在运行或等待运行的进程。
当一个进程用完了它所分配到的时间片后，系统会将其挂起，并将CPU资源分配给下一个等待运行的进程。
这种算法可以避免“饥饿”现象，并且能够保证所有正在运行或等待运行的进程都能够得到CPU资源。
但是，如果时间片太小，会导致进程频繁切换，影响系统性能；如果时间片太大，会导致长作业等待时间变长。
先来先服务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算法通常被用于处理较短的作业。
作业调度算法
作业调度算法先来先服务算法是最简单的调度算法之一、它按照作业到达的先后顺序进行调度，即先到达的作业先执行，后到达的作业后执行。
这种算法的优点是实现简单，适用于一些简单的场景。
然而，它的缺点也很明显，即平均等待时间较长，可能会导致长作业时间的作业一直占用CPU，造成资源浪费。
短作业算法是一种基于作业的执行时间长度进行调度的算法。
它会优先执行执行时间最短的作业。
这种算法的优点是能够最大程度地减少平均等待时间，使得短作业能够快速得到执行。
然而，缺点是可能会导致长作业长时间等待，造成长作业的响应时间增长。
这两种算法在不同的场景下有着不同的应用。
先来先服务算法适用于任务到达时间相对较为平均的场景，能够保证公平性，使得每个作业都有机会得到执行。
而短作业算法适用于任务执行时间差距较大的场景，能够尽可能减少平均等待时间，并且能够提升系统的响应速度。
需要注意的是，这两种算法都存在一种问题，即长作业会一直占用CPU，可能造成短作业长时间等待。
为了解决这个问题，可以引入抢占式调度算法，例如短作业剩余时间优先算法（Shortest Remaining Time Next，SRTN）。
SRTN算法在执行过程中会动态地检测作业的执行时间，一旦有更短的作业到达，就会抢占当前的作业，提高了系统的性能。
总的来说，先来先服务算法和短作业算法都是作业调度中常用的算法。
在实际应用中，可以根据具体情况选择合适的算法，或者结合多种算法来获取更好的调度效果。
作业调度算法的选择对于系统的性能和资源利用率具有重要的影响，需要根据实际需求进行综合权衡。
关于作业调度算法
关于作业调度算法作业调度算法是指在计算机系统中对作业进行合理安排和调度的一种方法。
作业调度算法的目标是优化系统资源的利用，提高作业的响应时间和吞吐量，提高系统的整体性能。
在实际应用中，作业调度算法起着至关重要的作用。
作业调度算法有很多种，每种算法都有其适用的场景和特点。
下面将介绍几种常见的作业调度算法。
1.先来先服务(FCFS)算法：先来先服务算法是通过按照作业到达的顺序进行调度的算法。
简单来说，就是按照作业提交的先后顺序进行调度。
这种算法的特点是简单、公平，但是对于作业的响应时间和系统的吞吐量效果较差。
2.短作业优先(SJF)算法：短作业优先算法是根据作业的执行时间进行调度的算法。
它的原理是，执行时间短的作业能够更快地完成，从而能够提高系统的响应时间和吞吐量。
然而，这种算法容易导致长作业等待时间过长，从而影响长作业的执行效率。
3.最高响应比优先(HRRN)算法：最高响应比优先算法是根据作业的等待时间和执行时间的比值进行调度的算法。
它的原理是，等待时间长的作业和执行时间短的作业都有更高的响应比，因此优先调度等待时间长的作业。
这种算法能够兼顾作业的响应时间和系统的吞吐量。
4.时间片轮转(RR)算法：时间片轮转算法是指将CPU的执行时间分成多个时间片，每个时间片的长度固定，作业按照时间片的顺序进行调度。
当作业的执行时间超过一个时间片时，将被放入一个等待队列，并在下一个时间片重新调度。
这种算法能够保证每个作业都能获得一定的执行时间，但不能很好地兼顾作业的响应时间。
5.最短剩余时间(SRT)算法：最短剩余时间算法是在短作业优先算法的基础上进行优化得到的。
在该算法中，系统会根据当前作业的执行时间和剩余执行时间来选择下一个要执行的作业。
这种算法能够更加准确地估计作业的完成时间，从而提高系统的响应时间和吞吐量。
除了以上几种常见的作业调度算法，还有很多其他的算法可以根据系统的特点和需求进行选择和优化，如最短作业优先(SJN)算法、优先级调度算法、多级反馈队列调度算法等。
操作系统实验_先来先服务的调度算法及短作业优先
操作系统实验_先来先服务的调度算法及短作业优先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的分配，造成长时间的等待。
操作系统实验_先来先服务的调度算法及短作业优先
操作系统实验_先来先服务的调度算法及短作业优先先来先服务调度算法是一种非抢占式的调度算法，它按照作业到达的先后顺序将作业分配给CPU。
具体来说，当一个作业进入就绪队列时，调度程序将把它放在队列的末尾，然后从队列的头部选择一个作业执行。
只有当一个作业执行完成后，作业队列的头部才会选择下一个作业执行。
先来先服务调度算法的优点是简单易实现，没有复杂的排序操作，适用于短作业和长作业混合的场景。
其缺点是没有考虑作业的执行时间，导致长作业会占用CPU很长时间，影响其他作业的响应时间。
短作业优先调度算法是一种抢占式的调度算法，它根据作业的执行时间选择优先级。
具体来说，当一个作业进入就绪队列时，调度程序会比较该作业的执行时间和其他就绪作业的执行时间，并选择执行时间最短的作业执行。
如果有一个新的作业到达，且其执行时间比当前执行的作业要短，那么调度程序会中断当前作业的执行并切换到新的作业执行。
短作业优先调度算法的优点是能够最大程度上减少作业的等待时间和响应时间，提高系统的吞吐量。
其缺点是需要对作业的执行时间有较准确的估计，否则可能导致长作业陷入饥饿状态。
此外，由于需要频繁进行作业的切换，短作业优先调度算法在实现上相对复杂。
在实际应用中，先来先服务调度算法适用于短作业和长作业混合的场景，或者作业的执行时间无法估计准确的情况下。
例如，在批处理系统中，作业的执行时间往往是固定的，先来先服务调度算法可以保证公平性，并且能够有效利用CPU资源。
而短作业优先调度算法适用于多任务环境下，作业的执行时间可以估计准确的情况下。
例如，在交互式系统中，用户的操作往往是短暂的，短作业优先调度算法可以最大限度地减少用户的等待时间，提高系统的响应速度。
总之，先来先服务调度算法和短作业优先调度算法是操作系统中常用的两种调度算法。
它们分别适用于不同的应用场景，在实际应用中可以根据具体需求选择不同的调度算法。
几种操作系统调度算法
几种操作系统调度算法操作系统调度算法是操作系统中用于确定进程执行的顺序和优先级的一种方法。
不同的调度算法有不同的优缺点，适用于不同的场景和需求。
下面将介绍几种常见的操作系统调度算法：1.先来先服务（FCFS）调度算法:先来先服务调度算法是最简单的调度算法之一、按照进程到达的顺序进行调度，首先到达的进程先执行，在CPU空闲时执行下一个进程。
这种算法实现简单，并且公平。
但是，由于没有考虑进程的执行时间，可能会导致长作业时间的进程占用CPU资源较长时间，从而影响其他进程的响应时间。
2.短作业优先（SJF）调度算法:短作业优先调度算法是根据进程的执行时间进行排序，并按照执行时间最短的进程优先执行。
这种算法可以减少平均等待时间，提高系统的吞吐量。
然而，对于长作业时间的进程来说，等待时间会相对较长。
3.优先级调度算法:优先级调度算法是根据每个进程的优先级来决定执行顺序的。
优先级可以由用户设置或者是根据进程的重要性、紧迫程度等因素自动确定。
具有较高优先级的进程将具有更高的执行优先级。
这种算法可以根据不同情况进行灵活调度，但是如果不恰当地设置优先级，可能会导致低优先级的进程长时间等待。
4.时间片轮转（RR）调度算法:时间片轮转调度算法将一个固定的时间片分配给每个进程，当一个进程的时间片用完时，将该进程挂起，调度下一个进程运行。
这种算法可以确保每个进程获得一定的CPU时间，提高系统的公平性和响应速度。
但是，对于长时间运行的进程来说，可能会引起频繁的上下文切换，导致额外的开销。
5.多级反馈队列（MFQ）调度算法:多级反馈队列调度算法将进程队列划分为多个优先级队列，每个队列有不同的时间片大小和优先级。
新到达的进程被插入到最高优先级队列，如果进程在时间片内没有完成，则被移到下一个较低优先级队列。
这种算法可以根据进程的执行表现自动调整优先级和时间片，更好地适应动态变化的环境。
以上是几种常见的操作系统调度算法，每种算法都有其优缺点和适用场景。
作业调度算法先来先服务算法短作业算法页
作业调度算法: 先来先服务算法、短作业优先算法引言在计算机操作系统中，作业调度算法是一种重要的技术，用于管理和调度计算机系统中的作业。
作业调度算法决定了如何分配计算机资源，以便最大化系统的效率和吞吐量。
本文将介绍两种常见的作业调度算法：先来先服务算法（First Come First Serve，FCFS）和短作业优先算法（Shortest Job First，SJF）。
先来先服务算法（FCFS）先来先服务算法是最简单的作业调度算法之一。
按照作业提交的顺序进行调度，先提交的作业先执行，后提交的作业则等待。
这种调度算法不考虑作业的执行时间或优先级，只根据作业提交的先后顺序来进行调度。
算法流程1.将作业按照提交的先后顺序排列。
2.按照排列顺序执行作业。
优点•算法实现简单，易于理解和实现。
•适用于短作业或者作业提交顺序代表了作业的优先级的情况。
缺点•短作业可能因为长作业的存在而等待时间过长，导致响应时间较长。
•不考虑作业执行时间，可能导致平均等待时间和平均周转时间较长。
•无法适应不同作业的执行时间需求。
短作业优先算法（SJF）短作业优先算法是一种将作业按照执行时间长度进行排序的作业调度算法。
在短作业优先算法中，最短执行时间的作业先执行，以此类推。
该算法可以最大程度地减少作业的等待时间和周转时间。
算法流程1.将作业按照执行时间长度从短到长进行排序。
2.按照排列顺序执行作业。
优点•可以最大程度地减少作业的等待时间和周转时间。
•适用于短作业和长作业相互混合的情况。
缺点•难以准确估计作业的执行时间，可能导致长作业等待时间过长。
•需要预先知道作业的执行时间长度才能进行排序。
•不适用于长作业占主导地位的情况。
性能对比与选择先来先服务算法和短作业优先算法都有其优点和缺点。
选择合适的算法取决于具体的应用场景和需求。
•如果作业都很短，并且没有严格的截止时间要求，先来先服务算法可以简单高效地满足需求。
•如果作业的执行时间非常重要，并且具有较严格的截止时间要求，短作业优先算法可以最大程度地减少作业的等待时间和周转时间。
各类作业调度算法
各类作业调度算法作业调度是计算机系统中的重要问题，涉及到如何合理地分配和调度系统资源，以最大化系统的吞吐量和性能。
针对不同的应用场景和需求，有多种不同的作业调度算法。
本文将介绍几种常见的作业调度算法，包括先来先服务调度算法（FCFS）、最短作业优先调度算法（SJF）、优先级调度算法、轮转调度算法（RR）和最高响应比优先调度算法（HRRN）。
先来先服务调度算法（FCFS）是最简单的一种调度算法。
它按照作业的到达时间顺序为其分配资源，即先来的作业先执行，后来的作业后执行。
这种算法的优点是实现简单，公平性好，但是缺点也很明显，它无法考虑作业的执行时间，如果一个长作业在前面执行，可能会导致后面的短作业等待时间过长，从而影响整个系统的效率。
最短作业优先调度算法（SJF）是一种根据作业执行时间的长短来分配资源的算法。
它会选择剩余执行时间最短的作业来执行，从而最大程度上减少作业的等待时间。
这种算法可以很好地提高系统的性能，但是需要事先知道每个作业的执行时间，而且无法应对作业执行时间波动较大的情况。
优先级调度算法主要根据作业的优先级来决定资源的分配顺序。
每个作业都有一个对应的优先级，具有较高优先级的作业会被优先调度执行。
不同作业的优先级可以通过用户设置或者系统自动派发来确定。
这种算法可以灵活地应对不同的需求，但是需要合理设置优先级，否则可能导致资源被一直分配给优先级较高的作业，而忽略其他作业。
轮转调度算法（RR）是一种按照时间片轮流分配资源的算法。
每个作业都有一个固定的时间片，当一个作业的时间片用完后，就将资源分配给下一个作业。
这种算法可以平衡各个作业的等待时间，对于长作业和短作业都能有一定的公平性，但是如果时间片设置得过长，可能导致系统响应时间较长。
最高响应比优先调度算法（HRRN）是根据作业的响应比来决定资源分配顺序的算法。
响应比由作业的等待时间与执行时间之比计算得出，作业的响应比越高，代表其等待时间相对较长，应该优先进行资源分配。
先来先服务和短作业优先调度算法
先来先服务调度算法和短作业优先调度算法
作业
提交 时间
运行 时间
开始 时间
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
先来先服务和短作业优先调度算法
先来先服务和短作业优先调度算法在先来先服务调度算法中，操作系统先根据作业的提交顺序将作业按顺序放入就绪队列中，然后按队列的顺序依次执行作业。
当一个作业执行完成后，下一个作业才会开始执行。
优点：1.简单易实现：先来先服务调度算法的实现非常简单，只需按照作业到达的顺序进行调度即可。
2.公平性：先来先服务调度算法保证了作业的公平性，因为作业的执行顺序完全按照作业到达的顺序进行。
3.低开销：先来先服务调度算法没有额外的开销，只需进行简单的作业切换即可。
缺点：1.平均等待时间长：如果一个长作业先到达，那么后面的短作业就不得不等待较长的时间，导致平均等待时间较长。
2.未能充分利用资源：由于先来先服务调度算法没有对作业的执行时间进行优化，可能导致资源利用率较低，造成浪费。
短作业优先调度算法（Shortest Job First SJF）短作业优先调度算法是根据作业的执行时间来进行调度的。
它的原理是选择执行时间最短的作业优先执行，以此来减少作业的等待时间和周转时间。
在短作业优先调度算法中，操作系统会根据作业的执行时间将作业按照升序排序，然后按照顺序执行作业。
如果有多个作业的执行时间相同，那么可以按照先来先服务的原则进行调度。
优点：1.最小化平均等待时间：短作业优先调度算法根据作业的执行时间来进行调度，能够尽量减少作业的等待时间和周转时间，从而最小化平均等待时间。
2.高资源利用率：由于选择执行时间最短的作业优先执行，能够更加有效地利用系统资源。
缺点：1.难以预测执行时间：在实际情况下，很难准确地预测作业的执行时间，可能导致短作业优先调度算法的准确性下降。
2.可能导致长作业饥饿：如果有长作业在短作业优先调度算法中不断到达，那么短作业可能会一直被优先执行，从而造成长作业饥饿的问题。
总结：先来先服务调度算法和短作业优先调度算法都是常见的调度算法之一，各有其优缺点。
先来先服务调度算法简单易实现，但可能导致平均等待时间长；短作业优先调度算法能够最小化平均等待时间和提高资源利用率，但难以准确预测执行时间可能导致长作业饥饿的问题。
作业调度算法(先来先服务算法
作业调度算法(先来先服务算法先来先服务算法的原理是按照作业提交的顺序进行调度，即先提交的作业先执行，后提交的作业后执行。
该算法不考虑作业的执行时间或优先级，没有任何判断条件，只按照作业的到达时间来进行调度。
当一个作业到达时，将其放入就绪队列中，等待CPU执行。
先来先服务算法的优点是简单、公平，实现起来也比较容易。
它适用于作业的执行时间相对均匀分布的情况，不会出现饥饿的现象，保证了所有作业都有机会被执行。
另外，该算法的实现也比较简单，不需要进行复杂的排序或优先级判断。
然而，先来先服务算法也具有一些明显的缺点。
由于它只根据作业的到达时间来进行调度，而不考虑作业的执行时间，因此会导致短作业等待时间长的问题，即如果一个短作业在一个长作业之后到达，那么它必须等待长作业执行完毕后才能执行，造成了短作业的等待时间增加。
这种现象称为"饥饿"，会降低系统的吞吐量和执行效率。
另外，由于先来先服务算法未对作业的执行时间或优先级进行考虑，可能导致平均等待时间较长。
对于长时间执行的作业，可能会造成后续作业的延迟和响应时间增加。
此外，它也容易造成"中断骚扰"的问题，即一些作业得到CPU后被中断，然后又重新排队等待执行。
为了克服先来先服务算法的局限性，后续出现了更加优化的作业调度算法，如短作业优先算法（Shortest Job First, SJF）、最高优先级调度算法（Highest Priority First, HPF）等。
这些算法都根据作业的执行时间、优先级或其他条件进行调度，达到更加合理、高效地分配系统资源的目的。
综上所述，先来先服务算法作为基本的作业调度算法，具有简单、公平的特点，但也存在着等待时间长、吞吐量低等不足之处。
在实际应用中，需要根据具体的情况进行选择和优化，或者结合其他算法进行使用，以提高系统的整体性能和用户体验。
操作系统各种调度算法
操作系统各种调度算法⼀、批处理作业调度算法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时间的时候，它会被加入到就绪队列中，并在队列中等待调度。
当一个进程完成执行或者发生I/O等等中断时，会使得另一个就绪队列中最前面的进程进入执行状态。
FCFS 的核心思想是谁先到谁先服务，且进程的执行顺序是固定的。
FCFS调度算法的优点是简单直观，易于实现。
在短期调度中，它能够保证不会产生饥饿现象，即保证每个进程都有机会执行。
这使得FCFS 成为一种公平的调度算法。
此外，由于该算法不需要频繁的上下文切换，它在处理长作业的性能上会比其他算法高。
然而，先来先服务调度算法也存在一些缺点。
最主要的问题是平均等待时间较长。
由于所有进程都需要按照到达时间顺序执行，如果前面存在一个执行时间较长的进程，那么后面的进程都需要等待很久才能执行。
这会导致平均等待时间增加，系统的响应时间变慢。
此外，FCFS算法无法适应实时环境，即使有一个紧急的进程，也要等待前面的进程执行完成才能运行。
为了解决FCFS调度算法的平均等待时间较长的问题，短作业优先调度算法应运而生。
短作业优先调度算法是根据进程的执行时间进行排序，选择执行时间最短的进程先执行。
该算法的核心思想是尽量选择执行时间短的进程，以减少平均等待时间。
短作业优先调度算法的优点是能够最大程度地减少平均等待时间，提高系统的响应性能。
由于执行时间短的进程能够快速完成，其他进程就能更快地得到执行。
这种调度算法适用于多任务操作系统，在系统内同时存在多个进程的情况下能够提高系统效率。
此外，SJF算法也可以应用于实时系统，并能够满足紧急任务的需求。
然而，短作业优先调度算法也存在一些问题。
首先，该算法需要准确地预测每个进程的执行时间，否则可能会导致执行时间较长的进程一直等待。
其次，该算法可能产生饥饿现象，即执行时间长的进程可能会一直等待执行。
这是因为短作业优先调度算法会优先选择执行时间短的进程，导致执行时间长的进程无法得到及时执行。
计算机操作系统的调度算法
计算机操作系统的调度算法随着计算机技术的飞速发展，操作系统扮演着越来越重要的角色。
操作系统是计算机软件的一部分，负责管理计算机的各种资源，其中之一就是进程的调度算法。
调度算法是操作系统中负责决定进程执行顺序的重要组成部分。
它可以根据某些策略和规则，合理分配计算机的处理器资源，提高系统的性能和效率。
下面将为大家介绍一些常见的计算机操作系统调度算法。
1. 先来先服务(FCFS)调度算法先来先服务是最简单、最直观的调度算法之一。
按照进程到达的顺序依次分配处理器资源，无论进程的优先级和需要执行的时间。
这种算法的优点是简单易实现，但是无法适应不同种类进程的需求，容易导致长作业的执行时间过长而影响其他进程的运行。
2. 短作业优先(SJF)调度算法短作业优先调度算法是根据进程的服务时间来进行排序，并按照时间最短的顺序分配处理器资源。
短作业优先算法可以减少平均等待时间，但会导致长作业饥饿，即长时间等待的作业无法得到执行。
3. 优先级调度算法优先级调度算法根据进程的优先级来分配处理器资源。
每个进程都有一个优先级，优先级高的进程先得到执行。
这种算法可以根据不同作业的需求进行灵活调度，但是可能导致优先级过高的进程占用过多的资源，影响其他进程的执行。
4. 时间片轮转调度算法时间片轮转是一种常见的多任务调度算法。
它将处理器的时间分成若干个时间片，每个进程在一个时间片内得到执行，然后切换到下一个进程。
时间片轮转算法可以保证公平性，每个进程都有机会得到执行，但是对于长时间的作业，可能会导致上下文切换的频繁，降低系统的效率。
5. 多级反馈队列调度算法多级反馈队列调度算法将进程按照优先级划分到不同的队列中，每个队列有不同的时间片大小。
进程按照优先级先执行高优先级队列中的作业，而低优先级的进程则进入下一个队列等待执行。
这种算法结合了优先级调度和时间片轮转调度的特点，可以有效平衡系统的性能和公平性。
6. 最短剩余时间(SRT)调度算法最短剩余时间调度算法是短作业优先调度算法的一种改进。
操作系统实验_先来先服务的调度算法和短作业优先
操作系统实验_先来先服务的调度算法和短作业优先先来先服务（FCFS）调度算法是一种非抢占式调度算法，在这种算法中，进程按照到达系统的先后顺序执行，并且在一个进程执行完毕之前，不会有其他进程执行。
如果一个进程没有执行完成，后续进程需要等待。
FCFS调度算法的优点是实现简单，公平性好。
由于按照到达时间先后顺序执行进程，能够保证所有进程都能够得到执行的机会。
然而，FCFS调度算法容易出现“饥饿”现象，即如果一个进程占用了较长的CPU时间，其他进程可能需要等待较长时间。
短作业优先（SJF）调度算法是一种非抢占式调度算法，它选择下一个执行的进程是根据预计的执行时间最短的进程。
在SJF调度算法中，进程按照预计的执行时间进行排序，并按照顺序执行。
SJF调度算法的优点是能够最大程度地减少平均等待时间。
因为进程按照预计的执行时间最短的顺序执行，执行时间短的进程优先执行，可以最大限度地减少其他进程等待的时间。
然而，SJF调度算法需要预先知道所有进程的执行时间，并且如果一个进程执行时间长，其他进程需要等待的时间可能会很长。
FCFS调度算法和SJF调度算法都有各自的优点和局限性。
FCFS调度算法适用于进程执行时间相对均匀的情况，可以保证所有进程都能够得到执行的机会。
但是，如果一个进程执行时间很长，可能会导致其他进程等待的时间非常长，容易出现“饥饿”现象。
SJF调度算法适用于进程执行时间差异较大的情况，可以最大程度地减少平均等待时间。
但是，SJF调度算法需要预先知道所有进程的执行时间，而且在实际应用中，很难准确预测进程的执行时间。
在实验中，可以通过编写相应的模拟程序来实现FCFS调度算法和SJF调度算法。
可以设定一个进程队列，每个进程有自己的到达时间和执行时间。
按照FCFS算法，按照到达时间先后顺序执行进程；按照SJF算法，按照执行时间从小到大的顺序执行进程。
通过模拟进程的调度过程，可以观察到FCFS算法和SJF算法的效果差异。
操作系统调度算法
操作系统调度算法操作系统调度算法是操作系统中一个重要的概念，它决定了进程如何被分配和执行。
调度算法的好坏直接关系到系统的性能和用户体验。
本文将介绍几种常见的操作系统调度算法，并分析它们的特点和适用场景。
先来了解一下什么是操作系统调度算法。
操作系统中可能同时存在多个进程，而CPU只能一次执行一个进程，因此需要调度算法来确定优先级和执行顺序。
调度算法的目标一般包括提高系统吞吐量、降低响应时间、提高公平性等。
下面是几种常见的调度算法。
1. 先来先服务调度算法（FCFS）先来先服务调度算法是最简单的调度算法之一，按照进程到达的顺序进行调度。
它的优点是实现简单，公平性较好，但是可能会导致平均等待时间较长。
当一个长时间运行的进程在等待短进程结束时，会出现所谓的“饥饿”问题。
2. 短作业优先调度算法（SJF）短作业优先调度算法是按照进程运行时间长度来调度的，即运行时间短的进程优先被执行。
它的优点是平均等待时间较短，但是无法处理长进程的“饥饿”问题。
此外，该算法对进程运行时间的准确预测要求较高。
3. 时间片轮转调度算法（RR）时间片轮转调度算法是按照时间片来调度的，每个进程被分配一个固定的时间片，当时间片用完后，如果进程还未完成，则将其放入就绪队列的末尾，并将下一个进程调度到CPU上执行。
这样可以保证每个进程都有机会执行，但是如果时间片设置不合理，会出现频繁的上下文切换，导致系统开销增大。
4. 优先级调度算法优先级调度算法是根据进程的优先级来进行调度的，优先级高的进程优先执行。
优先级可以是静态的，由系统管理员或进程创建者指定，也可以是动态的，根据运行情况进行调整。
该算法存在优先级翻转和饥饿问题，需要合理设计。
以上只是简要介绍了几种常见的操作系统调度算法，实际上还有很多其他算法，如多级反馈队列调度算法、最短剩余时间优先调度算法等。
选择适合的调度算法需要根据具体的应用场景和需求来决定。
总结一下，操作系统调度算法是操作系统中一个重要的概念，它决定了进程的执行顺序和优先级。
操作系统实验_先来先服务的调度算法和短作业优先
操作系统实验_先来先服务的调度算法和短作业优先操作系统中的进程调度算法是实现多道程序设计的关键，作为操作系统中的调度器，它决定了进程在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、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《操作系统》实验报告题目：作业调度算法班级：网络工程姓名：朱锦涛学号：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;}实验结果：系统自动为每个算法模拟分配五个作业，同时随机生成作业的编号，作业的到达时间，作业估计运行的时间。