下载文档原格式
操作系统短作业优先进程调度算法操作系统中的进程调度算法是指决定哪个进程在一些时间点被执行的规则和策略。
短作业优先（SJF）是一种常见的进程调度算法，它根据进程的执行时间来安排执行顺序。
短作业优先算法的思想是，优先调度执行所需执行时间最短的进程，以最大程度地减少平均等待时间和周转时间。
这个算法适合用于处理那些执行时间相对较短的任务。
SJF算法可以按两种方式实现：非抢占和抢占。
非抢占式短作业优先调度算法是指一旦一个进程开始执行，就不能被中断或抢占，直到它完成或由于其中一种原因被阻塞。
抢占式短作业优先调度算法是指一个新到达的进程可以抢占正在执行的进程，如果新到达的进程的执行时间比当前正在执行的进程更短。
对于非抢占式短作业优先调度算法，可以使用一个队列来保存进程，并通过比较它们的执行时间来确定下一个要执行的进程。
具体实现如下：1.首先，将所有待处理的进程添加到队列中。
2.对队列中的进程按照执行时间进行排序，按照从短到长的顺序执行。
3.执行每个进程直到完成，然后将其从队列中移除。
4.重复步骤3，直到所有进程都执行完成。
对于抢占式短作业优先调度算法，可以使用一个就绪队列和一个运行队列来实现。
就绪队列用于保存已到达但尚未执行的进程，而运行队列是当前正在运行的进程。
具体实现如下：1.首先，将所有到达的进程添加到就绪队列中，按照到达时间进行排序。
2.从就绪队列中选择执行时间最短的进程，并将其添加到运行队列中。
3.执行运行队列中的进程直到完成或被抢占。
4.如果有新的进程到达，将其加入到就绪队列中。
5.如果当前运行的进程被抢占，将其放回就绪队列中，并选择一个新的执行时间最短的进程来执行。
6.重复步骤3至5，直到所有进程都完成。
非抢占式短作业优先调度算法可以保证最短平均等待时间和周转时间，但存在一个问题，即长作业会被无限期地推迟。
为了解决这个问题，可以使用抢占式短作业优先调度算法，但这也会导致较多的上下文切换。
因此，根据具体情况和需求，可以选择适合的算法来实现进程调度。
操作系统实验_先来先服务的调度算法及短作业优先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的分配，造成长时间的等待。
短作业优先调度算法例题详解
（原创实用版）
目录
1.短作业优先调度算法的概述
2.算法的例子
3.算法的详解
4.算法的优点和缺点
正文
一、短作业优先调度算法的概述
短作业优先调度算法（Shortest Job First, SJF）是一种常见的作业调度算法。
这种算法的基本原则是优先执行估计运行时间最短的作业，直到完成。
然后，再从剩下的作业中选择估计运行时间最短的作业执行，以此类推。
这种算法的目的是尽可能减少作业的平均等待时间。
二、算法的例子
假设有一个计算机系统，其中有三个作业需要执行，它们的运行时间分别是：作业 1 需要 20 分钟，作业 2 需要 30 分钟，作业 3 需要 10 分钟。
按照短作业优先调度算法，执行顺序应为：先执行作业 3（10 分钟），然后执行作业 1（20 分钟），最后执行作业 2（30 分钟）。
三、算法的详解
短作业优先调度算法的执行过程可以分为以下几个步骤：
1.首先，将等待执行的作业按照运行时间从短到长进行排序。
2.然后，选择运行时间最短的作业执行，直到完成。
3.完成后，再从剩下的作业中选择运行时间最短的作业执行，以此类推。
四、算法的优点和缺点
短作业优先调度算法的优点是能够使得作业的平均等待时间最短，从而提高了系统的效率。
然而，这种算法也有其缺点，那就是长作业可能会被频繁地打断，导致其执行效率低下。
操作系统中常用作业调度算法的分析作业调度是操作系统中的一个重要组成部分，它负责对待执行的作业进行排队和调度，以最大化系统资源的利用效率、满足用户需求、保证系统稳定性等目标。
常见的作业调度算法有先来先服务（FCFS）、最短作业优先（SJF）、优先级调度、时间片轮转（RR）等，接下来我们分别对这几种算法进行分析。
1. FCFS调度算法先来先服务调度算法是操作系统中最简单的一种调度算法，也是最常用的一种调度算法。
它的处理方式是根据提交时间顺序，按照FIFO的顺序进行调度。
该算法的优点是简单易用，而且很容易实现。
同时，对于大多数情况下，该算法的资源分配相对公平。
但是，该算法存在着一些问题。
当一个作业的执行时间较长时，会大大降低系统的吞吐量，严重影响系统的效率。
因此，在实际应用中，该算法往往不能满足对作业的实时响应和高效完成的要求。
最短作业优先调度算法是一种非抢占式调度算法，它将作业按照其需要执行的时间长短大小进行排序，然后从执行时间最短的作业开始调度。
在实际应用中，该算法可以减少平均等待时间和平均周转时间，提高系统的效率和性能。
但是，该算法有个致命的缺点——它无法预测作业的执行时间。
如果一个长作业被排在了等待队列的前面，那么所有后续的短作业都要等待非常长的时间，这可能导致饥饿现象的出现。
3. 优先级调度算法优先调度算法是一种根据作业优先级大小进行调度的算法，可以根据作业的重要程度或紧急程度来设置不同的优先级。
该算法可以提高系统的响应速度和稳定性，满足系统特定的需求。
但是，该算法也存在着一些问题。
如果一个作业的优先级太高，那么其余的作业可能会一直处于等待状态，这种情况也会导致饥饿现象的出现。
此外，该算法的优先级设置需要有一定的经验和技巧，否则可能会对系统的性能产生不良影响。
4. 时间片轮转算法时间片轮转算法是一种循环调度算法，它将CPU的时间分成多个固定大小的时间片，然后在每个时间片内轮流执行等待队列中的作业，以便平均分配CPU资源。
操作系统实验_先来先服务的调度算法及短作业优先先来先服务调度算法是一种非抢占式的调度算法，它按照作业到达的先后顺序将作业分配给CPU。
具体来说，当一个作业进入就绪队列时，调度程序将把它放在队列的末尾，然后从队列的头部选择一个作业执行。
只有当一个作业执行完成后，作业队列的头部才会选择下一个作业执行。
先来先服务调度算法的优点是简单易实现，没有复杂的排序操作，适用于短作业和长作业混合的场景。
其缺点是没有考虑作业的执行时间，导致长作业会占用CPU很长时间，影响其他作业的响应时间。
短作业优先调度算法是一种抢占式的调度算法，它根据作业的执行时间选择优先级。
具体来说，当一个作业进入就绪队列时，调度程序会比较该作业的执行时间和其他就绪作业的执行时间，并选择执行时间最短的作业执行。
如果有一个新的作业到达，且其执行时间比当前执行的作业要短，那么调度程序会中断当前作业的执行并切换到新的作业执行。
短作业优先调度算法的优点是能够最大程度上减少作业的等待时间和响应时间，提高系统的吞吐量。
其缺点是需要对作业的执行时间有较准确的估计，否则可能导致长作业陷入饥饿状态。
此外，由于需要频繁进行作业的切换，短作业优先调度算法在实现上相对复杂。
在实际应用中，先来先服务调度算法适用于短作业和长作业混合的场景，或者作业的执行时间无法估计准确的情况下。
例如，在批处理系统中，作业的执行时间往往是固定的，先来先服务调度算法可以保证公平性，并且能够有效利用CPU资源。
而短作业优先调度算法适用于多任务环境下，作业的执行时间可以估计准确的情况下。
例如，在交互式系统中，用户的操作往往是短暂的，短作业优先调度算法可以最大限度地减少用户的等待时间，提高系统的响应速度。
总之，先来先服务调度算法和短作业优先调度算法是操作系统中常用的两种调度算法。
它们分别适用于不同的应用场景，在实际应用中可以根据具体需求选择不同的调度算法。
sjf算法例题详解(一)SJF算法例题1. 什么是SJF算法？•SJF算法（Shortest Job First，短作业优先算法）是一种操作系统调度算法。
•它的原则是按照作业的执行时间来进行调度，执行时间短的作业会被优先调度执行。
•SJF算法适用于一些具有明确执行时间的作业，能够提高作业的响应速度和系统的整体利用率。
2. SJF算法的例题考虑以下作业列表及其执行时间：作业列表：[A, B, C, D]执行时间：[5, 3, 8, 2]3. 算法过程按照SJF算法的原则，我们需要对作业列表进行排序，排序的依据是作业的执行时间。
排序后的作业列表如下：作业列表：[D, B, A, C]执行时间：[2, 3, 5, 8]4. 执行顺序根据排序后的作业列表，我们按照顺序执行作业。
执行顺序为：D -> B -> A -> C5. 算法优势SJF算法的优势在于能够减少作业的等待时间和响应时间，提高系统的整体效率。
6. 算法局限性SJF算法的局限性在于对作业的执行时间需求较高，如果无法准确估计作业的执行时间，可能会导致调度不准确。
7. 结论SJF算法是一种高效的操作系统调度算法，适用于有明确执行时间的作业。
它能够提高作业的响应速度和系统的整体利用率，但对作业的执行时间估计要求较高。
在实际应用中，可以根据任务的执行时间情况选择合适的调度算法以提高系统性能。
以上是对SJF算法例题的详细解释，希望能够对读者有所帮助。
SJF算法例题1. 什么是SJF算法？•SJF算法（Shortest Job First，短作业优先算法）是一种操作系统调度算法。
•它的原则是按照作业的执行时间来进行调度，执行时间短的作业会被优先调度执行。
•SJF算法适用于一些具有明确执行时间的作业，能够提高作业的响应速度和系统的整体利用率。
2. SJF算法的例题考虑以下作业列表及其执行时间：•作业列表：[A, B, C, D]•执行时间：[5, 3, 8, 2]3. 算法过程按照SJF算法的原则，我们需要对作业列表进行排序，排序的依据是作业的执行时间。
几种操作系统调度算法操作系统调度算法是操作系统中用于确定进程执行的顺序和优先级的一种方法。
不同的调度算法有不同的优缺点，适用于不同的场景和需求。
下面将介绍几种常见的操作系统调度算法：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.按照排列顺序执行作业。
优点•可以最大程度地减少作业的等待时间和周转时间。
•适用于短作业和长作业相互混合的情况。
缺点•难以准确估计作业的执行时间，可能导致长作业等待时间过长。
•需要预先知道作业的执行时间长度才能进行排序。
•不适用于长作业占主导地位的情况。
性能对比与选择先来先服务算法和短作业优先算法都有其优点和缺点。
选择合适的算法取决于具体的应用场景和需求。
•如果作业都很短，并且没有严格的截止时间要求，先来先服务算法可以简单高效地满足需求。
•如果作业的执行时间非常重要，并且具有较严格的截止时间要求，短作业优先算法可以最大程度地减少作业的等待时间和周转时间。
操作系统短作业优先调度算法操作系统的短作业优先调度算法（Shortest Job First Scheduling，简称SJF）是一种用于进程调度的算法。
它的优势在于能够最小化平均等待时间，并且适用于批处理系统。
在本文中，我们将对SJF算法进行详细解释，并讨论其优缺点以及适用场景。
SJF算法的基本思想是优先选择估计完成时间最短的任务进行调度。
在该算法中，每个进程都与一个估计运行时间相关联，估计时间越短的进程将被优先调度执行。
通常情况下，进程的估计运行时间由之前的执行时间或者进程已经消耗的CPU周期数量来确定。
SJF算法可以分为两种类型：非抢占式和抢占式。
在非抢占式SJF中，一旦进程开始执行，它将一直运行直到完成。
而在抢占式SJF中，如果一个新进程的估计时间更短，则当前正在执行的进程将被暂停，并且将被新进程替换。
具体来说，SJF算法的执行步骤如下：1.从就绪队列中选择估计运行时间最短的进程。
2.若操作系统支持抢占式调度，则如果有一个新进程的估计时间更短，那么当前正在执行的进程将被抢占。
3.执行选定的进程，并更新进程的状态和估计运行时间。
4.如果进程未完成，则将其放回就绪队列，并重复第1步。
5.如果所有进程都已完成，则算法结束。
SJF调度算法的优点在于能够最小化平均等待时间，因为估计时间最短的进程将会先执行，而不会被长时间的进程阻塞。
这使得系统能够更高效地利用CPU资源，提高运行效率。
然而，SJF算法也有一些缺点。
首先，它要求对进程的估计运行时间有准确的预测，但在实际情况中，很难准确预测每个进程的运行时间。
其次，SJF算法对于长时间的进程可能会产生不公平现象，因为这些进程可能需要等待很长时间才能得到执行。
此外，SJF算法还有一些适用场景。
它特别适合用于批处理系统或长时间运行的作业，其中有多个进程需要按照最短运行时间进行调度。
这样可以确保任务能够快速完成并提高整体系统效率。
综上所述，SJF算法是一种用于进程调度的短作业优先调度算法。
【操作系统】先来先服务和短作业优先算法（C语⾔实现）【操作系统】先来先服务算法和短作业优先算法实现介绍:1.先来先服务 (FCFS: first come first service)如果早就绪的进程排在就绪队列的前⾯，迟就绪的进程排在就绪队列的后⾯，那么先来先服务(FCFS: first come first service)总是把当前处于就绪队列之⾸的那个进程调度到运⾏状态。
也就说，它只考虑进程进⼊就绪队列的先后，⽽不考虑它的下⼀个CPU周期的长短及其他因素。
FCFS算法简单易⾏，是⼀种⾮抢占式策略，但性能却不⼤好。
简单来说，先来先服务就是那个进程到达时间最早，那么CPU就先处理哪个进程。
2.短作业优先（SJF, Shortest Job First）对预计执⾏时间短的作业（进程）优先分派处理机。
通常后来的短作业不抢先正在执⾏的作业。
也就是说，不但要考虑进程的到达时间，还要考虑进程需要运⾏的时间。
当⼀个进程正在运⾏时，假如有其他的进程到达，那么这些到达的进程就需要按照其需要运⾏的时间长短排序，运⾏时间短的在前，运⾏时间长的在后。
3.例⼦：4.运⾏截图1.先来先服务2.短作业优先5.话不多说，直接上代码。
第⼀次写，有很多不⾜的地⽅。
希望⼤家看到可以帮忙纠正⼀下，谢谢⼤家。
#include <stdio.h>#include <stdlib.h>#define MAX 10typedef struct PCB {int id,arrive_time,service_time,start_time,finish_time; //进程id、到达时间、服务时间、开始时间、完成时间float zhouzhuan_time,daiquanzhouzhuan_time; //周转时间、带权周转时间。
只能说我的拼英。
emm，。
尴尬。
int status;}PCB;typedef enum {OK,ERROR}Status;typedef enum {FALSE,TRUE}Bool;typedef PCB datatype;typedef struct LinkQueue {int front;int rear;int length;datatype* base;}quene;int arrive[MAX]; // 记录每个作业的到达时间int service[MAX]; //记录每个作业的服务时间int num; //输⼊的进程个数quene init(){quene q_pcb;q_pcb.base = (datatype *)malloc(sizeof(datatype)*MAX);q_pcb.front = q_pcb.rear = 0;q_pcb.length = 0;return q_pcb;}Bool isFull(quene *q) {if ((q->rear + 1) % MAX == q->front) {return TRUE;}return FALSE;}Bool isEmpty(quene *q) {if (q->rear == q->front) {return TRUE;}return FALSE;}Status rudui(quene *q,datatype p){ //⼊队。
课程设计采用短作业优先调度算法调度程序学号：姓名：专业：指导老师：日期：目录一、实验题目 (3)二、课程设计的目的 (3)三、设计内容 (3)四、设计要求 (3)五、主要数据结构及其说明 (4)六、程序运行结果 (5)七、流程图 (7)八、源程序文件 (9)九、实验体会 (13)十、参考文献 (13)摘要在多道程序环境下，主存中有着多个进程，其数目往往多于处理机数目。
这就要求系统能按某种算法，动态地把处理机分配给就绪队列中的一个进程，使之执行。
分配处理机的任务是由处理机调度程序完成的。
由于处理机是最重要的计算机资源，提高处理机的利用率及改善系统性能（吞吐量、响应时间），在很大程度上取决于处理机调度性能的好坏，因而，处理机调度便成为操作系统设计的中心问题之一。
在多道程序系统中，一个作业被提交后必须经过处理机调度后，方能获得处理机执行。
对于批量型作业而言，通常需要经历作业调度和进程调度两个过程后方能获得处理机。
作业调度是对成批进入系统的用户作业，根据作业控制块的信息，按一定的策略选取若干个作业使它们可以去获得处理器运行的一项工作。
而对每个用户来说总希望自己的作业的周转时间是最小的，短作业优先（SJF）便是其中一种调度方法。
本次课程设计主要是模拟短作业优先(SJF)调度算法。
一、实验题目采用短作业优先算法的的进程调度程序二、课程设计的目的●操作系统课程设计是计算机专业重要的教学环节，它为学生提供了一个既动手又动脑，将课本上的理论知识和实际有机的结合一起，独立分析和解决实际问题的机会。
●进一步巩固和复习操作系统的基础知识。
●培养学生结构化程序、模块化程序设计的方法和能力。
●提高学生调试程序的技巧和软件设计的能力。
●提高学生分析问题、解决问题以及综合利用C语言进行程序设计的能力。
三、设计内容设计并实现一个采用短作业优先算的进程调度算法演示程序四、设计要求1. 每一个进程有一个PCB，其内容可以根据具体情况设定。
2. 进程数、进入内存时间、要求服务时间、优先级等均可以在界面上设定3. 可读取样例数据（要求存放在外部文件中）进行进程数、进入内存时间、时间片长度、进程优先级的初始化4. 可以在运行中显示各进程的状态：就绪、执行（由于不要求设置互斥资源与进程间同步关系，故只有两种状态）5. 采用可视化界面，可在进程调度过程中随时暂停调度，查看当前进程的状态以及相应的阻塞队列五、主要数据结构及其说明算法的基本概念和原理：本次课程设计主要是采用短作业优先算法进程的进程调度过程。
短作业优先调度算法，是指对短作业或短进程优先调度的算法。
他们可以分别用于作业调度和进程调度，短作业优先的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将他们调入内存运行。
而短进程优先调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给他，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再度重新调度。
本程序采用了非抢占式短作业优先调度。
而非抢占式这种方式，一旦把处理机分配给某进程后，便让该进程一直执行，直至该进程完成或发生某事件而被阻塞时，才再把处理机分配给其它进程，决不允许某进程抢占已经分配出去的处理机。
这种调度方式的优点是实现简单，系统开销小，适用于大多数的批处理系统环境。
但它难以满足紧急任务的要求——立即执行，因而可能造成难以预料的后果。
因此，在要求比较严格的实时系统中，不宜采用这种调度方式。
本课程设计主要是在满足要求多道单处理机的情况下进行短作业的优先调度。
算法的简要说明：短作业（进程）优先调度算法SJ（P）F，是指对短作业或短进程优先调度的算法。
它们可以分别用于作业调度和进程调度。
短作业优先（SJF）的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。
而短进程（SPF）调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机再重新调度。
优点是SJ(P)F 调度算法能有效地降低作业（进程）的平均等待时间，提高系统吞吐量。
缺点是该算法对长作业不利；完全未考虑作业的紧迫程度，因而不能保证紧迫性作业（进程）长期不被调度；由于作业（进程）的长短只是根据用户所提供的估计执行时间而定的，而用户又可能会有意或无意地缩短其作业的估计运行时间，致使该算法不一定能真正做到短作业游戏那调度。
该程序定义了一个进程数据块(struct Process_)，该数据块有进程名(name)、到达时间(arrivetime)、服务时间(servicetime)、开始执行时间(starttime)、完成时间(finishtime)、周转时间(zztime)、带权周转时间(dqzztime)、执行顺序（order）。
用到的公式有：完成时间=到达时间+服务时间；周转时间=完成时间+到达时间；带权周转时间=周转时间/服务时间；(第一次执行的进程的完成时间=该进程的到达时间；下一个进程的开始执行时间=上一个进程的完成时间)。
运行进程的顺序需要对进程的到达时间和服务时间进行比较。
如果某一进程是从0时刻到达的，那么首先执行该进程；之后就比较进程的服务时间，谁的服务时间短就先执行谁（如果服务时间相同则看它们的到达时间，到达时间短的先执行）；如果到达时间和服务时间相同，则按先来先服务算法执行。
六、程序运行结果1 进入操作界面如下2输入进程的信息3 各时刻进程的状态4 进程信息5 平均带权周转时间界面七、流程图本次课程设计主要是通过比较各个进程的优先级以及各进程所需要占用的CPU时间来确定哪个作业优先运行，短作业优先调度算法除了能保证优先级更高的作业优先运行外，还能使相同优先级的前提下，所需CPU时间最短的那个作业优先运行，次外，本次课程设计还增加了阻塞时间和被阻塞时间来对个进程的运行加以控制。
此次课程设计的总体流程图如下：八、源程序文件#include<iostream>#define MaxNum 100using namespace std;struct Process_struct{int Number; //进程编号char Name[MaxNum]; //进程名称int ArrivalTime; //到达时间int ServiceTime; //开始运行时间int FinishTime; //运行结束时间int WholeTime; //运行时间int run_flag; //调度标志int order; //运行次序double WeightWholeTime; //周转时间double AverageWT_FCFS,AverageWT_SJF; //平均周转时间double AverageWWT_FCFS,AverageWWT_SJF; //平均带权周转时间}Process[MaxNum];int N; //实际进程个数int SJF(); //短作业优先int SJF(){ //短作业优先算法int temp_time=0; //当期那时间int i=0,j;int number_schedul,temp_counter; //进程编号，当前已执行进程个数float run_time;run_time=Process[i].WholeTime;j=1;while((j<N)&&(Process[i].ArrivalTime==Process[j].ArrivalTime)) //判断是否有两个进程同时到达{if(Process[j].WholeTime<Process[i].WholeTime){run_time=Process[i].WholeTime;i=j;}j++;}//查找下一个被调度的进程//对找到的下一个被调度的进程求相应的参数number_schedul=i;Process[number_schedul].ServiceTime=Process[number_schedul].ArrivalTime;Process[number_schedul].FinishTime=Process[number_schedul].ServiceTime+Process[number_schedul].WholeTime;Process[number_schedul].run_flag=1;temp_time=Process[number_schedul].FinishTime;Process[number_schedul].order=1;temp_counter=1;while(temp_counter<N){for(j=0;j<N;j++){if((Process[j].ArrivalTime<=temp_time)&&(!Process[j].run_flag)){run_time=Process[j].WholeTime;number_schedul=j;break;}}for(j=0;j<N;j++){if((Process[j].ArrivalTime<=temp_time)&&(!Process[j].run_flag))if(Process[j].WholeTime<run_time){run_time=Process[j].WholeTime;number_schedul=j;}}//查找下一个被调度的进程//对找到的下一个被调度的进程求相应的参数Process[number_schedul].ServiceTime=temp_time;Process[number_schedul].FinishTime=Process[number_schedul].ServiceTime+Pr ocess[number_schedul].WholeTime;Process[number_schedul].run_flag=1;temp_time=Process[number_schedul].FinishTime;temp_counter++;Process[number_schedul].order=temp_counter;}return 0;}int Pinput(); //进程参数输入int Poutput(); //调度结果输出void main(){int option;printf(" ********************主菜单************************\n");printf(" * 1 使用短作业优先*\n");printf(" * 0 退出*\n");printf("**************************************************\n");//system("cls");system("color 1f");scanf("%d",&option);switch(option){case 0:printf("运行结束。
