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

课程设计

采用短作业优先调度算法调度程序

学号：

姓名：

专业：

指导老师：

日期：

目录

一、实验题目 (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

#define MaxNum 100

using 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

{

if(Process[j].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+Pr

ocess[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

{

for(j=0;j

{

if((Process[j].ArrivalTime<=temp_time)&&(!Process[j].run_flag))

{

run_time=Process[j].WholeTime;

number_schedul=j;

break;

}

}

for(j=0;j

{

if((Process[j].ArrivalTime<=temp_time)&&(!Process[j].run_flag))

if(Process[j].WholeTime

{

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("运行结束。\n");

break;

case 1:

printf("对进程用短作业优先调度。\n\n");

Pinput();

SJF();

Poutput();

break;

}

}

int Pinput() //进程参数输入

{

int i;

printf("请输入进程个数:\n");

scanf("%d",&N);

for(i=0;i

{

printf("***************************************\n");

printf("请输入一个进程:\n",i+1);

printf("请输入进程名称:\n");

scanf("%s",Process[i].Name);

printf("请输入到达时间:\n");

scanf("%d",&Process[i].ArrivalTime);

printf("请输入服务时间:\n");

scanf("%d",&Process[i].WholeTime);

Process[i].ServiceTime=0;

Process[i].FinishTime=0;

Process[i].WeightWholeTime=0;

Process[i].order=0;

Process[i].run_flag=0;

system("cls");

}return 0;

}

int Poutput() //调度结果输出

{

int i;

float turn_round_time=0,f1,w=0;

printf(" 进程名称到达T 运行T 开始运行T 结束T 执行顺序周转T 带权周转T\n");

for(i=0;i

{

Process[i].WeightWholeTime=Process[i].FinishTime-Process[i].ArrivalTime;

f1=Process[i].WeightWholeTime/Process[i].WholeTime;

turn_round_time+=Process[i].WeightWholeTime;

w+=f1;

printf("时刻%d :",Process[i].ServiceTime,Process[i].Name);

printf(" %s %d %d %d %d %d %f %f\n",Process[i].Name,Process[i].ArrivalTime,Process[i].WholeTime,Process[

i].ServiceTime,Process[i].FinishTime,Process[i].order,Process[i].WeightWholeTime,f

1);

}

printf("average_turn_round_timer=%f\n",turn_round_time/N);

printf("weight_average_turn_round_timer=%f\n",w/N);

return 0;

}

九、实验体会

通过本次课程设计，使我对计算机操作系统短作业优先调度算法这一节的知识有了更深的了解。短作业优先调度算法易于实现，并且效率很高，但是短作业只考虑到短作业的利益，而不顾长作业，这样就可能会使得长作业一直处于等待状态而不能运行。所以，短作业优先算法适用于系统中短作业较多的情况。此外，通过本次实验，进一步巩固和复习操作系统的基础知识，更进一步的了解了结构化模块化程序设计的方法，提高了调试程序的技巧，提高了自己的动手能力我对操作系统中的作业调度模拟和短作业优先算法有了更深的认识。并且发现，只看课本上的知识远远不够，只一味学习也根本没用，必须要动手亲自实践，才能真正掌握所学的东西。虽然在这次课程设计过程中，我们也遇到了很多问题，但我们都能保持一个良好的心态，不急不躁，并且能通过请教老师，与同学们积极讨论，查看课外资料，反复实验，反复检查，将问题一个个解答，并最终成功的完成本次课程设计。课程设计结束了，在这次的课程设计中不仅检验了我所学习的知识，也培养了我如何去做一件事情，又如何完成一件事情的能力。

通过模拟进程的调度问题，更加深了我对于操作系统理论的理解，在自己的动手操作过程中，能够体会成功的喜悦和遇到问题自己解决的能力，对于我来说是一次提高，让自己多多的在实践中可以加深对理论的理解，也让我明白了以后应该如何更好，更高效的学习，在以后，我会更加努力。

总之，本次课程设计让我们学到了很多东西，包括课本上的和课外的，是一个非常有意义的课程设计。

十、参考文献

1）宗大华，宗涛，陈吉人著操作系统北京：人民邮电出版社，2009 2）李爱华，程磊著面相对象程序设计（C++语言）北京: 清华大学出版社，2010

3）宋晓宇， windows操作系统核心编程实验教程中国铁道出版社

4）张丽芬刘利雄王金玉编著操作系统实验教程清华大学出版社

短作业优先调度算法例题详解

短作业优先调度算法例题详解 短作业优先调度算法例题详解 什么是短作业优先调度算法？ 短作业优先调度算法是一种常见的进程调度算法，它的主要思想是优先调度执行当前剩余运行时间最短的作业。在这种算法下，长时间作业的响应时间会相对较长，但是短时间作业的响应时间会更短。算法原理 短作业优先调度算法的原理是按照作业的执行时间来进行调度，优先选择执行时间较短的作业。当一个作业到达时，操作系统会检查作业的执行时间，并将其与已有作业的执行时间进行比较，选择执行时间最短的作业进行调度。 算法实现 以下是一个简单的短作业优先调度算法的例子： 1.输入作业的数量和每个作业的执行时间。 2.按照作业的执行时间对作业进行排序，从执行时间最短的作业开 始执行。 3.执行作业直到所有作业执行完毕。

例题解析 假设有三个作业需要执行，它们的执行时间分别为5、2和8。使 用短作业优先调度算法对这些作业进行调度。 1.首先，按照作业的执行时间对作业进行排序，排序后的顺序为2、 5和8。 2.执行时间最短的作业是2，因此首先执行该作业，剩下的两个作 业的执行时间分别为5和8。 3.接下来，执行时间较短的作业是5，执行该作业后，剩下的作业 的执行时间为8。 4.最后，执行剩下的唯一一个作业，执行时间为8。 根据以上步骤，最终的作业执行顺序为2、5和8。 优缺点分析 短作业优先调度算法的优点是能够最大程度地缩短短时间作业的 响应时间，提高系统的吞吐量。然而，这种算法容易造成长时间作业 的等待时间过长，可能会导致长时间作业的执行效率较低。 总结 短作业优先调度算法是一种常见的进程调度算法，其核心原理是 选择执行时间最短的作业进行调度。通过对作业的排序和执行，可以 最大程度地减少短时间作业的响应时间。然而，这种算法也存在一些

最短作业优先调度算法

最短作业优先调度算法 一、前言 最短作业优先调度算法（Shortest Job First，简称SJF）是一种常见的进程调度算法，主要用于处理多个进程同时请求资源的情况。SJF算法的核心思想是优先调度执行时间最短的进程，以提高系统的响应速度和效率。 二、SJF算法的原理 SJF算法是一种非抢占式调度算法，即一旦一个进程被分配到CPU上运行，它将一直运行直到完成或者被阻塞。该算法基于每个进程的执行时间来进行排序，并按照顺序依次执行。 三、SJF算法的实现 1. 首先需要获取所有待调度进程的执行时间，并按照从小到大的顺序进行排序。 2. 将排序后的进程依次加入就绪队列中。 3. 从就绪队列中选择执行时间最短的进程，并将其分配给CPU进行运行。 4. 如果该进程在运行过程中发生阻塞，则将其移到阻塞队列中等待唤醒。 5. 当一个进程完成时，检查就绪队列中是否还有未完成的进程，如果

有，则重复步骤3；否则结束调度。 四、SJF算法存在的问题 1. SJF算法假设能够准确地知道每个进程的执行时间，但实际上这是 很难做到的。如果估算不准，可能会导致进程等待时间过长或者资源 浪费。 2. SJF算法容易出现“饥饿”现象，即某些进程由于执行时间较长而 一直无法被调度执行。 3. SJF算法可能会导致运行时间较短的进程优先级过高，而忽略了其 他因素如优先级、进程类型等。 五、SJF算法的改进 针对SJF算法存在的问题，可以采取以下措施进行改进： 1. 引入抢占式调度机制，在某些情况下可以强制中断正在运行的进程，并将CPU分配给更紧急的任务。 2. 采用动态优先级调度策略，将每个进程的优先级根据其等待时间进 行动态调整。当一个进程等待时间越长时，其优先级越高。 3. 综合考虑多种因素来确定每个进程的优先级。除了执行时间外，还 应考虑其他因素如I/O操作、内存需求、用户优先级等。 六、总结 SJF算法是一种简单有效的调度算法，在处理大量短作业请求时具有较

短作业优先调度算法

短作业优先调度算法 SJF算法的核心思想是最短作业先执行，这样可以最大化利用CPU资源，减少平均等待时间和作业的响应时间。它适用于批处理系统和交互式系统。 SJF算法的实现包括两种方式：非抢占式和抢占式。 非抢占式SJF算法： 在非抢占式SJF算法中，一旦CPU开始执行一个作业，它会一直执行完毕，直到作业完成或者发生I/O请求。当一个新的作业到达时，系统会比较该作业的执行时间和当前正在执行的作业的剩余执行时间，如果新作业的执行时间较短，则优先执行新作业。 抢占式SJF算法： 在抢占式SJF算法中，一旦有一个新的作业到达，并且它的执行时间比当前正在执行的作业短，操作系统会暂停当前作业的执行，将CPU分配给新作业，等新作业执行完毕后再继续执行之前的作业。抢占式SJF算法需要操作系统具备抢占能力，即能够中断并恢复作业的执行。 SJF算法的优点是可以最大化利用CPU资源，减少平均等待时间和作业的响应时间，适用于CPU密集型的作业。然而，SJF算法也存在一些问题和局限性： 1.预测执行时间的困难：在实际系统中，很难准确预测一个作业的执行时间，因此SJF算法可能会出现误判，导致等待时间增加。

2.饥饿问题：如果有大量的短作业不断到达，长作业可能会一直等待。这种情况称为饥饿问题，长作业可能无法获取足够的CPU时间，导致低响 应性。 3.处理I/O请求的处理：SJF算法无法解决I/O请求的调度问题，因 此需要结合其他算法来处理。 为了解决SJF算法存在的问题，还发展了一些改进的版本，如最短剩 余时间优先算法（Shortest Remaining Time First, SRTF），该算法在 抢占式的基础上，可以在作业执行过程中切换到更短的作业，以进一步减 少等待时间。 总结起来，SJF算法是一种重要的进程调度算法，它按照作业的执行 时间来确定优先级。它的优点是可以最大化利用CPU资源，减少等待时间 和作业响应时间。然而，它也存在预测执行时间困难、饥饿问题和无法解 决I/O请求的问题。为了解决这些问题，可以使用改进的版本或结合其他 算法来处理。

操作系统调度算法

操作系统调度算法 操作系统调度算法是指操作系统在多个进程间进行调度和分配处理 器资源的算法。它的目标是提高系统的吞吐量、响应时间和资源利用率，使得各个进程能够公平合理地获得处理器的时间片。 一、先进先出（First-Come First-Served, FCFS）算法 先进先出算法是最简单的调度算法之一，它按照进程到达的先后顺 序进行调度。当一个进程首次到达时，它会被放入就绪队列的末尾等 待调度。一旦当前正在执行的进程释放了处理器，就会选择就绪队列 中排在最前面的进程进行调度。 这种算法的优点是公平且易于实现。然而，由于没有考虑进程的执 行时间长短，可能会导致长作业等待时间过长，影响系统的响应时间。因此，在实际应用中，FCFS算法常常需要与其他调度算法结合使用。 二、最短作业优先（Shortest Job First, SJF）算法 最短作业优先算法通过预测每个作业的执行时间来进行调度。它选 择预计执行时间最短的作业，以保证系统具有最短的平均等待时间。 这种算法的优点是能够最大程度地减少平均等待时间，并且能够有 效地避免长作业等待时间过长的问题。然而，由于需要预测作业的执 行时间，而且难以准确预测，因此实际应用中的SJF算法通常采用近 似估计的方式，如短程作业优先算法（Shortest Remaining Time First, SRTF）。

三、轮转调度（Round Robin, RR）算法 轮转调度算法是一种时间片轮转的算法，它将处理器的时间分成若干个时间片，每个进程在一个时间片内执行，然后被挂起，等待下一次调度。 这种算法的优点是公平，每个进程都能获得一定的处理时间，而且可以较好地满足对响应时间的要求。然而，如果时间片过短，会增加上下文切换的开销；如果时间片过长，会导致长作业等待时间过长。因此，选择合适的时间片大小非常重要。 四、多级反馈队列（Multilevel Feedback Queue, MFQ）算法 多级反馈队列算法是一种综合了FCFS和轮转调度的算法。它将就绪队列划分为多个队列，每个队列有不同的优先级和时间片大小。进程在各个队列之间进行调度，根据进程的执行时间和历史行为决定是否调整优先级和时间片大小。 这种算法的优点是能够根据进程的行为动态调整调度策略，根据进程的特点进一步提高系统的吞吐量和响应时间。然而，由于队列的划分和参数的设置比较复杂，调度算法的性能高度依赖于这些参数的选择。 总结： 操作系统调度算法是操作系统中的关键技术之一，它直接影响到系统的性能和用户的体验。不同的调度算法有不同的特点和适用场景，选择合适的调度算法对于提高系统的性能至关重要。在实际应用中，

操作系统实验_先来先服务的调度算法和短作业优先

操作系统实验_先来先服务的调度算法和短作业优先 操作系统中的进程调度算法是实现多道程序设计的关键，作为操作系 统中的调度器，它决定了进程在CPU上执行的顺序，直接影响到系统的性 能和响应时间。本文将重点介绍两种常用的进程调度算法：先来先服务调 度算法（FCFS）和短作业优先调度算法（SJF）。 先来先服务调度算法是一种最简单、最基础的调度算法，其实现非常 简单：按照进程到达CPU的先后顺序，将其依次调入CPU执行。当一个进 程进入就绪队列后，在CPU空闲的时候，就将其调入CPU执行，直到进程 执行完成或者主动放弃CPU时间片。这种调度算法的优势在于实现简单、 公平性好；但其缺点也很明显，由于没有考虑进程的执行时间长短，如果 一个长时间的进程先到达就绪队列，则会造成其他进程的等待时间过长， 导致系统的响应时间较长。 与FCFS相对的是短作业优先调度算法（Shortest Job First, SJF）。SJF调度算法会根据进程的相对执行时间长短来进行调度，即将执行时间 最短的进程优先调度进入CPU执行。SJF算法的关键在于如何估计进程的 执行时间，通常有两种方法：预测和历史信息。预测方法是根据进程的相 关信息，如进程的大小、执行时间等进行预测；而历史信息方法是根据以 往同类任务的执行时间的平均值或历史执行时间进行估算。在实际操作中，通常采用后者进行调度。SJF调度算法的优势在于可以最大程度地减少平 均等待时间，提高系统的响应效率。然而，该算法也存在一些问题，如如 何准确估算进程的执行时间、对长时间任务不够友好等。 两种调度算法各自都有其优势和劣势，因此在实际操作中需要根据具 体的情况选择适用的调度算法。如果系统中存在大量长时间任务，可以考 虑使用FCFS来保证公平性；而如果系统中的任务短且繁琐，可以优先考

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

操作系统中常用作业调度算法的分析 作业调度是操作系统中的一个重要组成部分，它负责对待执行的作业进行排队和调度，以最大化系统资源的利用效率、满足用户需求、保证系统稳定性等目标。常见的作业调度 算法有先来先服务（FCFS）、最短作业优先（SJF）、优先级调度、时间片轮转（RR）等，接下来我们分别对这几种算法进行分析。 1. FCFS调度算法 先来先服务调度算法是操作系统中最简单的一种调度算法，也是最常用的一种调度算法。它的处理方式是根据提交时间顺序，按照FIFO的顺序进行调度。该算法的优点是简 单易用，而且很容易实现。同时，对于大多数情况下，该算法的资源分配相对公平。 但是，该算法存在着一些问题。当一个作业的执行时间较长时，会大大降低系统的吞 吐量，严重影响系统的效率。因此，在实际应用中，该算法往往不能满足对作业的实时响 应和高效完成的要求。 最短作业优先调度算法是一种非抢占式调度算法，它将作业按照其需要执行的时间长 短大小进行排序，然后从执行时间最短的作业开始调度。在实际应用中，该算法可以减少 平均等待时间和平均周转时间，提高系统的效率和性能。 但是，该算法有个致命的缺点——它无法预测作业的执行时间。如果一个长作业被排 在了等待队列的前面，那么所有后续的短作业都要等待非常长的时间，这可能导致饥饿现 象的出现。 3. 优先级调度算法 优先调度算法是一种根据作业优先级大小进行调度的算法，可以根据作业的重要程度 或紧急程度来设置不同的优先级。该算法可以提高系统的响应速度和稳定性，满足系统特 定的需求。 但是，该算法也存在着一些问题。如果一个作业的优先级太高，那么其余的作业可能 会一直处于等待状态，这种情况也会导致饥饿现象的出现。此外，该算法的优先级设置需 要有一定的经验和技巧，否则可能会对系统的性能产生不良影响。 4. 时间片轮转算法 时间片轮转算法是一种循环调度算法，它将CPU的时间分成多个固定大小的时间片， 然后在每个时间片内轮流执行等待队列中的作业，以便平均分配CPU资源。该算法提高了 系统的作业响应速度，降低了平均等待时间和平均周转时间。 但是，该算法在长作业存在的时候，可能存在大量的作业调度开销。同时，该算法也 难以处理用户的实时操作需求，因此需要设置合理的时间片长度。

操作系统实验_先来先服务的调度算法及短作业优先

操作系统实验_先来先服务的调度算法及短作业优先 先来先服务调度算法是一种非抢占式的调度算法，它按照作业到达的 先后顺序将作业分配给CPU。具体来说，当一个作业进入就绪队列时，调 度程序将把它放在队列的末尾，然后从队列的头部选择一个作业执行。只 有当一个作业执行完成后，作业队列的头部才会选择下一个作业执行。 先来先服务调度算法的优点是简单易实现，没有复杂的排序操作，适 用于短作业和长作业混合的场景。其缺点是没有考虑作业的执行时间，导 致长作业会占用CPU很长时间，影响其他作业的响应时间。 短作业优先调度算法是一种抢占式的调度算法，它根据作业的执行时 间选择优先级。具体来说，当一个作业进入就绪队列时，调度程序会比较 该作业的执行时间和其他就绪作业的执行时间，并选择执行时间最短的作 业执行。如果有一个新的作业到达，且其执行时间比当前执行的作业要短，那么调度程序会中断当前作业的执行并切换到新的作业执行。 短作业优先调度算法的优点是能够最大程度上减少作业的等待时间和 响应时间，提高系统的吞吐量。其缺点是需要对作业的执行时间有较准确 的估计，否则可能导致长作业陷入饥饿状态。此外，由于需要频繁进行作 业的切换，短作业优先调度算法在实现上相对复杂。 在实际应用中，先来先服务调度算法适用于短作业和长作业混合的场景，或者作业的执行时间无法估计准确的情况下。例如，在批处理系统中，作业的执行时间往往是固定的，先来先服务调度算法可以保证公平性，并 且能够有效利用CPU资源。 而短作业优先调度算法适用于多任务环境下，作业的执行时间可以估 计准确的情况下。例如，在交互式系统中，用户的操作往往是短暂的，短

短作业优先调度算法

青岛理工大学 操作系统课程设计报告 院（系）：计算机工程学院 专业：计算机科学与技术专业 学生姓名: 班级：＿＿学号: 题目：短作业优先调度算法的进程调度程序＿ 起迄日期:＿＿＿＿＿＿＿＿ 设计地点: 指导教师: 2011—2012年度第 1 学期 完成日期: 2012 年 1 月日

一、课程设计目的 进行操作系统课程设计主要是在学习操作系统课程的基础上，在完成操作系统各部分实验的基础上，对操作系统的整体进行一个模拟，通过实践加深对各个部分的管理功能的认识，还能进一步分析各个部分之间的联系，最后达到对完整系统的理解。同时，可以提高运用操作系统知识解决实际问题的能力；锻炼实际的编程能力、开发软件的能力；还能提高调查研究、查阅技术文献、资料以及编写软件设计文档的能力。 二、课程设计内容与要求 设计目的：在多道程序和多任务系统中，系统内同时处于就绪状态的进程可能有若干个，且进程之间也存在着同步与互斥的关系，要求采用指定的调度策略，使系统中的进程有条不紊地工作，通过观察诸进程的运行过程，以巩固和加深处理机调度的概念。 2、设计要求（多道、单处理机）： 1)每一个进程有一个PCB，其内容可以根据具体情况设定。 2)可以在界面设定的互斥资源（包括两种：输入设备与输出设备）的数目 3)进程数、进入内存时间、要求服务时间可以在界面上进行设定 4)进程之间存在一定的同步与互斥关系，可以通过界面进行设定，其表示方法如下： 进程的服务时间由三段组成：I2C10O5（表示进程的服务时间由2个时间片的输入，10个时间片的计算，5个时间片的输出） 进程间的同步关系用一个段表示：W2，表示该进程先要等待P2进程执行结束后才可以运行 因此，进程间的同步与互斥关系、服务时间可以统一用四段表示为：I2C10O5W2 5)可以在运行中显示各进程的状态：就绪、阻塞、执行 6)采用可视化界面，可在进程调度过程中随时暂停调度，查看当前进程的状态以及相 应的阻塞队列 7)具有一定的数据容错性 三、系统分析与设计 1、系统分析 本系统主要是采用短作业优先算法进程的进程调度过程。短作业优先调度算法，是指对短作业或短进程优先调度的算法。他们可以分别用于作业调度和进程调度，短作业优先的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将他们调入内存运行。而短进程优先调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给他，，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再度重新调度。本程序采用了非抢占式短作业优先调度。而非抢占式这种方式，一旦把处理机分配给某进程后，便让该进程一直执行，直至该进程完成或发生某事件而被阻塞时，才再把处理机分配给其它进程，决不允许某进程抢占已经分配出去的处理机。这种调度方式的优点是实现简单，系统开销小，适用于大多数的批处理系统环境。但它难以满足紧急任务的要求——立即执行，因而可能造成难以预料的后果。因此，在要求比较严格的实时系统中，不宜采用这种调度方式本系统的主要是在满足要求多道单处理机的情况下进行短作业的优先调度。 本系统在测试时输入了五个进程，按实验要求如I2C10O5（表示进程的服务时间由2个时间片的输入，10个时间片的计算，5个时间片的输出，5个时间片的计算组成）的方式输入，各进程的信息如下：（0 0 1 1 1 ）（1 2 1 2 2 ）（2 4 1 1 1 ）

操作系统的调度算法

操作系统的调度算法 操作系统是计算机系统中的核心软件，用于管理和控制计算机硬件 和软件资源，为应用程序提供运行环境。在操作系统中，调度算法是 一种决定多个进程或线程之间执行顺序的方法。本文将介绍操作系统 中常见的调度算法及其应用。 一、先来先服务（First-Come, First-Served，FCFS）调度算法 先来先服务调度算法是最基本的调度算法，按照任务到达的顺序执行。当一个进程请求使用CPU时，CPU将分配给该进程，并一直执行 直到进程终止。如果有多个进程同时到达，它们将按照到达的先后顺 序排队等待。 FCFS调度算法的优点是简单、公平，每个进程都能得到平等的执 行机会。然而，它也存在一些缺点。当一个长时间运行的进程占用 CPU时，其他进程需要等待较长时间，导致响应时间较长。同时，FCFS算法无法适应不同进程的优先级和紧急程度。 二、短作业优先（Shortest Job First，SJF）调度算法 短作业优先调度算法是根据任务执行时间长短来进行调度的。当一 个进程请求使用CPU时，CPU将分配给执行时间最短的进程。在短作 业优先调度算法中，可以采用非抢占方式，即一旦某个进程开始执行，其他进程将等待。 SJF调度算法的优势是可以最大程度地减少平均等待时间和响应时间。较短的作业可以迅速完成，等待时间较长的进程将被推迟执行，

从而减少了整体的等待时间。然而，SJF调度算法可能导致长作业长时 间等待，造成资源浪费。 三、优先级调度算法 优先级调度算法根据进程的优先级确定调度顺序，优先级高的进程 将先执行。在优先级调度算法中，每个进程都被赋予一个优先级，通 常是一个整数，较小的数值表示较高的优先级。 优先级调度算法可以根据不同的任务需求和进程类型进行灵活调整。高优先级的进程可以获得较多的CPU资源，较低优先级的进程可以在 无需即时响应的情况下等待。然而，优先级调度算法容易导致优先级 较低的进程长时间等待，可能引发饥饿问题。 四、时间片轮转（Round Robin，RR）调度算法 时间片轮转调度算法是将CPU时间划分为固定大小的时间片，每 个进程被分配一个时间片进行执行。当时间片用完后，进程将被暂停 执行，等待下一轮调度。如果进程在时间片结束前完成任务，则将释 放CPU资源给下一个等待进程。 时间片轮转调度算法的优势是可以保证公平性，每个进程都有机会 获得CPU时间，减少了长作业的等待时间。然而，时间片过短会导致 高频率的上下文切换，造成额外的开销和系统资源浪费。同时，对于 较长的作业，仍可能产生较长的响应时间。 五、多级反馈队列调度算法

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

#include #include using namespace std; struct SJF{ char name[6];//进程名 float arrivetime;//到达时间 float servicetime;//服务时间 float starttime;//开始执行时间 float finishtime;//完成时间 float zztime;//周转时间 float dqzztime;//带权周转时间 }; SJF a[100]; void input(SJF *p,int N) { int i; cout<<" 按照进程名到达时间服务时间的格式输入"<>p[i].name>>p[i].arrivetime>>p[i].servicetime; } } void Print(SJF *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float dqzztime,int N) { int k; cout<

操作系统作业调度算法

操作系统作业调度算法 操作系统作业调度算法是操作系统中的一个重要概念，它决定了在多道程序环境下，各个作业的执行顺序和分配时间。正确选择合适的调度算法可以提高系统的效率和性能，保证作业能够按时完成。本文将介绍几种常见的作业调度算法，包括先来先服务（FCFS）、短作业优先（SJF）、最高响应比优先（HRRN）和轮转法（RR）。 先来先服务（FCFS）调度算法是最简单的一种算法，它按照作业到达的先后顺序进行调度。当一个作业到达后，如果系统中没有其他作业在执行，则该作业立即执行；如果有其他作业在执行，则该作业会进入就绪队列等待。FCFS算法的优点是实现简单，但是它容易导致长作业等待时间过长，影响系统的响应时间。 短作业优先（SJF）调度算法是根据作业的执行时间来进行调度的。当一个作业到达后，系统会比较该作业的执行时间与当前正在执行的作业的执行时间，如果该作业的执行时间更短，则该作业会被优先执行。SJF算法的优点是能够减少作业的等待时间，提高系统的响应速度，但是它需要预先知道每个作业的执行时间，对于实时系统来说并不适用。 最高响应比优先（HRRN）调度算法是根据作业的等待时间和执行时间的比值来进行调度的。当一个作业到达后，系统会计算该作业的响应比，响应比越高，优先级越高，该作业会被优先执行。响应

比的计算公式为（等待时间+执行时间）/ 执行时间。HRRN算法的优点是能够兼顾作业的等待时间和执行时间，提高系统的整体性能，但是它需要不断地重新计算作业的响应比，增加了调度算法的复杂度。 轮转法（RR）调度算法是将系统的处理时间分为若干个时间片，每个时间片内一个作业可以执行的时间是固定的，当一个作业到达后，系统会将其放入就绪队列的末尾，并在当前时间片内执行该作业。当一个时间片结束后，如果作业还没有执行完，系统会将其放回就绪队列的末尾，等待下一轮的调度。轮转法算法的优点是能够公平地分配CPU时间，避免了长作业的等待时间过长，但是它可能导致一些短作业的响应时间较长。 除了以上几种常见的作业调度算法，还有一些其他的调度算法，如最短剩余时间优先（SRTF）、最高优先级优先（HPF）等。不同的调度算法适用于不同的应用场景，需要根据具体的系统需求和性能要求进行选择。 总结起来，操作系统作业调度算法是决定作业执行顺序和分配时间的重要算法。不同的调度算法有不同的优点和适用场景，选择合适的调度算法可以提高系统的效率和性能。在实际应用中，需要根据具体情况进行选择，并不断优化和改进调度算法，以适应不断变化的系统需求。

短作业优先算法

短作业（进程）优先调度算法 1.短作业（进程）优先调度算法SJ（P）F，是指对短作业或 短进程优先调度的算法。它们可以分别用于作业调度和进程调度。短作业优先（SJF）的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。而短进程（SPF）调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机再重新调度。 SJ(P)F调度算法能有效地降低作业（进程）的平均等待时间，提高系统吞吐量。该算法对长作业不利，完全未考虑作业的紧迫程度。 2.流程图

3.代码 #include #include #include struct sjf{ char name[10]; float arrivetime; float servicetime; float starttime; float finishtime; float zztime; float dqzztime; }; sjf a[100]; void input(sjf *p,int N) { int i; printf("intput the process's name & arrivetime & servicetime:\nfor exmple: a 0 100\n"); for(i=0;i<=N-1;i++) { printf("input the %dth process's information:\n",i+1); scanf("%s%f%f",&p[i].name,&p[i].arrivetime,&p[i].serviceti

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

课程设计 采用短作业优先调度算法调度程序 学号： 姓名： 专业： 指导老师： 日期：

目录 一、实验题目 (3) 二、课程设计的目的 (3) 三、设计内容 (3) 四、设计要求 (3) 五、主要数据结构及其说明 (4) 六、程序运行结果 (5) 七、流程图 (7) 八、源程序文件 (9) 九、实验体会 (13) 十、参考文献 (13)

摘要 在多道程序环境下，主存中有着多个进程，其数目往往多于处理机数目。这就要求系统能按某种算法，动态地把处理机分配给就绪队列中的一个进程，使之执行。分配处理机的任务是由处理机调度程序完成的。由于处理机是最重要的计算机资源，提高处理机的利用率及改善系统性能（吞吐量、响应时间），在很大程度上取决于处理机调度性能的好坏，因而，处理机调度便成为操作系统设计的中心问题之一。在多道程序系统中，一个作业被提交后必须经过处理机调度后，方能获得处理机执行。对于批量型作业而言，通常需要经历作业调度和进程调度两个过程后方能获得处理机。作业调度是对成批进入系统的用户作业，根据作业控制块的信息，按一定的策略选取若干个作业使它们可以去获得处理器运行的一项工作。而对每个用户来说总希望自己的作业的周转时间是最小的，短作业优先（SJF）便是其中一种调度方法。本次课程设计主要是模拟短作业优先(SJF)调度算法。

一、实验题目 采用短作业优先算法的的进程调度程序 二、课程设计的目的 ●操作系统课程设计是计算机专业重要的教学环节，它为学生提供了一个既动 手又动脑，将课本上的理论知识和实际有机的结合一起，独立分析和解决实际问题的机会。 ●进一步巩固和复习操作系统的基础知识。 ●培养学生结构化程序、模块化程序设计的方法和能力。 ●提高学生调试程序的技巧和软件设计的能力。 ●提高学生分析问题、解决问题以及综合利用C语言进行程序设计的能力。 三、设计内容 设计并实现一个采用短作业优先算的进程调度算法演示程序 四、设计要求 1. 每一个进程有一个PCB，其内容可以根据具体情况设定。 2. 进程数、进入内存时间、要求服务时间、优先级等均可以在界面上设定 3. 可读取样例数据（要求存放在外部文件中）进行进程数、进入内存时间、时间片长度、进程优先级的初始化 4. 可以在运行中显示各进程的状态：就绪、执行（由于不要求设置互斥资源与进程间同步关系，故只有两种状态） 5. 采用可视化界面，可在进程调度过程中随时暂停调度，查看当前进程的状态以及相应的阻塞队列

短作业优先调度算法

《操作系统》课程实验报告实验名称：短作业优先调度算法 姓名：陈凯 学号：541413430202 地点：四教楼301 指导老师：张旭 专业班级：嵌入式软件14-02

一、实验目的： 测试数据可以随即输入或从文件中读入。 必须要考虑到作业的到达时间 最终能够计算每一个作业的周转时间。 二、实验内容： 模拟实现短作业调度算法，具体如下： 设置作业体：作业名，作业的到达时间，服务时间，作业间的链接指针 进程初始化：由用户输入作业名、作业的到达时间和服务时间进行初始化。 显示函数：1、显示当前调度的是哪个作业，后备队列中有哪些作业 2、最终显示每个作业的作业名、到达时间、服务时间、完成时间和周转时间 排序函数：对就已到达的作业按照服务时间进行排序。注意考虑到达时间 调度函数：每次从已到达的作业队列队首调度优一个作业执行。 删除函数：作业结束后撤销。 三、实验代码 #include struct sjf //定义进程的结构体 { char name[10]; //进程名 float arrivetime; //到达时间 float servicetime; //服务时间 float starttime; //开始时间 float finishtime; //完成时间 float zztime; //周转时间 float dqzztime; //带权周转时间 }; sjf b[100]; //定义短作业优先算法进程的最大数量 void Sinput(sjf *p,int N) //输入函数 { int i; printf("输入进程的名称、到达时间、服务时间:\n");

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

操作系统短作业优先进程调度算法 操作系统中的进程调度算法是指决定哪个进程在一些时间点被执行的 规则和策略。短作业优先（SJF）是一种常见的进程调度算法，它根据进 程的执行时间来安排执行顺序。 短作业优先算法的思想是，优先调度执行所需执行时间最短的进程， 以最大程度地减少平均等待时间和周转时间。这个算法适合用于处理那些 执行时间相对较短的任务。 SJF算法可以按两种方式实现：非抢占和抢占。非抢占式短作业优先 调度算法是指一旦一个进程开始执行，就不能被中断或抢占，直到它完成 或由于其中一种原因被阻塞。抢占式短作业优先调度算法是指一个新到达 的进程可以抢占正在执行的进程，如果新到达的进程的执行时间比当前正 在执行的进程更短。 对于非抢占式短作业优先调度算法，可以使用一个队列来保存进程， 并通过比较它们的执行时间来确定下一个要执行的进程。具体实现如下： 1.首先，将所有待处理的进程添加到队列中。 2.对队列中的进程按照执行时间进行排序，按照从短到长的顺序执行。 3.执行每个进程直到完成，然后将其从队列中移除。 4.重复步骤3，直到所有进程都执行完成。 对于抢占式短作业优先调度算法，可以使用一个就绪队列和一个运行 队列来实现。就绪队列用于保存已到达但尚未执行的进程，而运行队列是 当前正在运行的进程。具体实现如下：

1.首先，将所有到达的进程添加到就绪队列中，按照到达时间进行排序。 2.从就绪队列中选择执行时间最短的进程，并将其添加到运行队列中。 3.执行运行队列中的进程直到完成或被抢占。 4.如果有新的进程到达，将其加入到就绪队列中。 5.如果当前运行的进程被抢占，将其放回就绪队列中，并选择一个新 的执行时间最短的进程来执行。 6.重复步骤3至5，直到所有进程都完成。 非抢占式短作业优先调度算法可以保证最短平均等待时间和周转时间，但存在一个问题，即长作业会被无限期地推迟。为了解决这个问题，可以 使用抢占式短作业优先调度算法，但这也会导致较多的上下文切换。因此，根据具体情况和需求，可以选择适合的算法来实现进程调度。

操作系统调度算法

操作系统调度算法 一、常见的批处理作业调度算法 1.先来先服务调度算法FCFS:就是按照各个作业进入系统的自然次序来调度作业。这 种调度算法的优点是实现简单，公平。其缺点是没有考虑到系统中各种资源的综合使用情况，往往使短作业的用户不满意，因为短作业等待处理的时间可能比实际运行时间长得多。 2.短作业优先调度算法SPF: 就是优先调度并处理短作业，所谓短是指作业的运行时 间短。而在作业未投入运行时，并不能知道它实际的运行时间的长短，因此需要用户在提 交作业时同时提交作业运行时间的估计值。 3.最高响应比优先算法HRN：FCFS可能造成短作业用户不满，SPF可能使得长作业用 户不满，于是提出HRN，选择响应比最高的作业运行。响应比=1+作业等待时间/作业处理 时间。 4. 基于优先数调度算法HPF：每一个作业规定一个表示该作业优先级别的整数，当需要将新的作业由输入井调入内存处理时，优先选择优先数最高的作业。 5.均衡调度算法，即多级队列调度算法 基本概念： 作业周转时间Ti=完成时间Tei-提交时间Tsi 作业平均周转时间T=周转时间/作业个数 作业带权周转时间Wi=周转时间/运行时间 响应比=等待时间+运行时间/运行时间 二、进程调度算法 1.先进先出算法FIFO：按照进程进入就绪队列的先后次序来选择。即每当进入进程调度，总是把就绪队列的队首进程投入运行。 2. 时间片轮转算法RR：分时系统的一种调度算法。轮转的基本思想是，将CPU的处理时间划分成一个个的时间片，就绪队列中的进程轮流运行一个时间片。当时间片结束时，就强迫进程让出CPU，该进程进入就绪队列，等待下一次调度，同时，进程调度又去选择就绪队列中的一个进程，分配给它一个时间片，以投入运行。 3. 最高优先级算法HPF：进程调度每次将处理机分配给具有最高优先级的就绪进程。最高优先级算法可与不同的CPU方式结合形成可抢占式最高优先级算法和不可抢占式最高 优先级算法。

操作系统四种调度算法

操作系统四种调度算法 操作系统四重调度算法之一、先来先服务调度算法 先来先服务FCFS调度算法是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。 操作系统四重调度算法之二、短作业进程优先调度算法 短作业进程优先调度算法SJPF，是指对短作业或短进程优先调度的算法。它们可以分别用于作业调度和进程调度。短作业优先SJF的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。而短进程优先SPF调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再重新调度。 操作系统四重调度算法之三、高优先权优先调度算法 1.优先权调度算法的类型 为了照顾紧迫型作业，使之在进入系统后便获得优先处理，引入了最高优先权优先FPF调度算法。此算法常被用于批处理系统中，作为作业调度算法，也作为多种操作系统中的进程调度算法，还可用于实时系统中。当把该算法用于作业调度时，系统将从后备队列中选择若干个优先权最高的作业装入内存。当用于进程调度时，该算法是把处理机分配给就绪队列中优先权最高的进程，这时，又可进一步把该算法分成如下两种。 1 非抢占式优先权算法 在这种方式下，系统一旦把处理机分配给就绪队列中优先权最高的进程后，该进程便一直执行下去，直至完成;或因发生某事件使该进程放弃处理机时，系统方可再将处理机重新分配给另一优先权最高的进程。这种调度算法主要用于批处理系统中;也可用于某些对实时性要求不严的实时系统中。 2 抢占式优先权调度算法 在这种方式下，系统同样是把处理机分配给优先权最高的进程，使之执行。但在其执行期间，只要又出现了另一个其优先权更高的进程，进程调度程序就立即停止当前进程原优先权最高的进程的执行，重新将处理机分配给新到的优先权最高的进程。因此，在采用这种调度算法时，是每当系统中出现一个新的就绪进程i 时，就将其优先权Pi与正在执行的进程j

短作业优先算法

短作业〔进程〕优先调度算法 1.短作业〔进程〕优先调度算法SJ〔P〕F，是指对短作业或 短进程优先调度的算法。它们可以分别用于作业调度和进程调度。短作业优先〔SJF〕的调度算法是从后备队列中选择一个或假设干个估计运行时间最短的作业，将它们调入内存运行。 而短进程〔SPF〕调度算法那么是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机再重新调度。 SJ(P)F调度算法能有效地降低作业〔进程〕的平均等待时间，提高系统吞吐量。该算法对长作业不利，完全未考虑作业的紧迫程度。 2.流程图

3.代码 #include<> #include<> #include<> struct sjf{ char name[10]; float arrivetime; float servicetime; float starttime; float finishtime; float zztime; float dqzztime; }; sjf a[100]; void input(sjf *p,int N) { int i; printf("intput the process's name & arrivetime & servicetime:\nfor exmple: a 0 100\n"); for(i=0;i<=N-1;i++) { printf("input the %dth process's information:\n",i+1); scanf("%s%f%f",&p[i].name,&p[i].arrivetime,&p[i].serviceti