3-2 作业调度算法
常用调度算法总结
⽬录1.2.3.1.2.4.1.2.5. 常⽤调度算法总结分类： 2013-08-10 17:59 71⼈阅读 (0)调度算法是指：根据系统的资源分配策略所规定的资源分配算法，如任务A在执⾏完后，选择哪个任务来执⾏，使得某个因素（如进程总执⾏时间，或者磁盘寻道时间等）最⼩。
对于不同的系统⽬标，通常采⽤不同的调度算法。
⼏个常⽤的操作系统进程调度算法。
1 先来先服务（队列）先来先服务(FCFS)调度算法是⼀种最简单的调度算法，该算法既可⽤于作业调度，也可⽤于进程调度。
当在作业调度中采⽤该算法时，每次调度都是从后备作业队列中选择⼀个或多个最先进⼊该队列的作业，将它们调⼊内存，为它们分配资源、创建进程，然后放⼊就绪队列。
在进程调度中采⽤FCFS算法时，则每次调度是从就绪队列中选择⼀个最先进⼊该队列的进程，为之分配处理机，使之投⼊运⾏。
该进程⼀直运⾏到完成或发⽣某事件⽽阻塞后才放弃处理机。
缺点：⽐较有利于长作业，⽽不利于短作业。
有利于CPU繁忙的作业，⽽不利于I/O 繁忙的作业。
2 最短优先（优先队列）最短优先调度算法是指对短作业或短进程优先调度的算法。
它们可以分别⽤于作业调度和进程调度。
短作业优先(SJF)的调度算法是从后备队列中选择⼀个或若⼲个估计运⾏时间最短的作业，将它们调⼊内存运⾏。
⽽短进程优先(SPF)调度算法则是从就绪队列中选出⼀个估计运⾏时间最短的进程，将处理机分配给它，使它⽴即执⾏并⼀直执⾏到完成，或发⽣某事件⽽被阻塞放弃处理机时再重新调度。
缺点：长作业的运⾏得不到保证。
2 ⾼优先权优先调度算法2.1 优先权调度算法的类型为了照顾紧迫型作业，使之在进⼊系统后便获得优先处理，引⼊了最⾼优先权优先(FPF)调度算法。
此算法常被⽤于批处理系统中，作为作业调度算法，也作为多种操作系统中的进程调度算法，还可⽤于实时系统中。
当把该算法⽤于作业调度时，系统将从后备队列中选择若⼲个优先权最⾼的作业装⼊内存。
操作系统中常用作业调度算法的分析
操作系统中常用作业调度算法的分析操作系统是计算机系统中最重要的组成部分之一，它负责管理计算机的各种资源并提供各种服务。
作业调度是操作系统的一个重要功能，它负责决定哪个作业在什么时候被执行。
为了更好地实现作业调度，操作系统中常用的作业调度算法有先来先服务（FCFS）、最短作业优先（SJF）、优先级调度、高响应比优先（HRRN）和时间片轮转等。
本文将对这些常用的作业调度算法进行分析，以便读者更好地理解它们的原理和应用。
1. 先来先服务（FCFS）先来先服务（FCFS）是最简单最直接的作业调度算法，它按照作业到达的先后顺序进行调度。
当一个作业到达后，操作系统会将其加入就绪队列，然后按照队列的先后顺序执行。
FCFS算法的优点是实现简单，代码简洁，但它也存在着明显的缺点，比如平均等待时间较长，无法适应多种作业的需要等。
由于FCFS算法对作业的执行时间没有考虑，所以可能导致长作业等待时间过长的问题，这就是著名的长作业效应。
2. 最短作业优先（SJF）最短作业优先（SJF）算法是一种按作业执行时间长度优先的调度算法，它会优先调度执行时间最短的作业。
相比于FCFS算法，SJF算法能够有效地减少平均等待时间，并且不会出现长作业效应。
SJF算法也存在着一个问题，即无法预知作业的执行时间，如果有一个长作业一直未能执行完毕，那么其他短作业就会一直等待，这就是短作业等待时间过长的问题。
为了解决这个问题，可以使用抢占式SJF算法，即当有一个短作业到来时，可以立即中断当前正在执行的长作业，这样可以更加公平地分配资源。
3. 优先级调度优先级调度是一种根据作业的优先级来进行调度的算法，优先级通常可以由作业的属性或者其他额外的信息决定。
优先级高的作业先被执行，如果有多个作业优先级相同，那么可以使用FCFS或者SJF等其他算法来决定先后顺序。
优先级调度算法的优点是可以根据不同的需求进行灵活的调度，但是也存在一些问题，比如可能会导致低优先级作业长时间等待而无法执行的情况。
关于作业调度算法
关于作业调度算法作业调度算法是计算机操作系统中的一个重要问题，它涉及到如何合理、高效地安排进程或任务在计算机系统中的执行顺序。
在操作系统中，进程是计算机执行任务的最小单位，作业调度算法的目标就是通过合理地调度进程，使得系统在保证资源利用率的同时，能够满足用户和系统的需求。
作业调度算法的设计与选择，对于计算机系统的性能和用户体验都有着重要的影响。
因此，作业调度算法需要综合考虑多个因素，如响应时间、吞吐量、资源利用率、公平性等。
以下是几种常见的作业调度算法的介绍：2. 短作业优先（Shortest-Job-First, SJF）算法：根据进程估计执行时间的长短进行调度，即优先选择执行时间最短的进程。
这个算法可以最大程度地减少平均等待时间，提高系统的响应速度，但需要预估进程的执行时间，对于预测不准确的情况，可能会导致长作业等待时间过长。
3.优先级调度算法：为每个进程分配一个优先级，根据优先级的高低进行调度。
这个算法可以根据系统和用户的需求，合理地安排进程的执行顺序，但需要考虑如何设置优先级，以及如何防止优先级反转等问题。
4. 时间片轮转（Round Robin, RR）算法：将每个进程分配一个固定的时间片，按照时间片顺序进行调度。
当一个进程的时间片用完后，将被强制切换到下一个进程，从而实现多个进程轮流执行。
这个算法可以实现公平调度，确保每个进程都能得到执行机会，但可能会导致上下文切换的开销过大，影响系统性能。
除了以上介绍的几种算法，还有很多其他的作业调度算法，如最高响应比优先（Highest-Response-Ratio-Next, HRRN）算法、多级反馈队列算法等，每种算法都有自己的优缺点，适用于不同的场景和需求。
在实际应用中，作业调度算法的设计和选择需要根据具体的情况进行评估和优化。
例如，对于高响应速度的实时系统，可能更适合使用短作业优先算法；对于需要兼顾公平性和资源利用率的系统，可能更适合使用多级反馈队列算法。
关于作业调度算法
关于作业调度算法作业调度算法是指在计算机系统中对作业进行合理安排和调度的一种方法。
作业调度算法的目标是优化系统资源的利用，提高作业的响应时间和吞吐量，提高系统的整体性能。
在实际应用中，作业调度算法起着至关重要的作用。
作业调度算法有很多种，每种算法都有其适用的场景和特点。
下面将介绍几种常见的作业调度算法。
1.先来先服务(FCFS)算法：先来先服务算法是通过按照作业到达的顺序进行调度的算法。
简单来说，就是按照作业提交的先后顺序进行调度。
这种算法的特点是简单、公平，但是对于作业的响应时间和系统的吞吐量效果较差。
2.短作业优先(SJF)算法：短作业优先算法是根据作业的执行时间进行调度的算法。
它的原理是，执行时间短的作业能够更快地完成，从而能够提高系统的响应时间和吞吐量。
然而，这种算法容易导致长作业等待时间过长，从而影响长作业的执行效率。
3.最高响应比优先(HRRN)算法：最高响应比优先算法是根据作业的等待时间和执行时间的比值进行调度的算法。
它的原理是，等待时间长的作业和执行时间短的作业都有更高的响应比，因此优先调度等待时间长的作业。
这种算法能够兼顾作业的响应时间和系统的吞吐量。
4.时间片轮转(RR)算法：时间片轮转算法是指将CPU的执行时间分成多个时间片，每个时间片的长度固定，作业按照时间片的顺序进行调度。
当作业的执行时间超过一个时间片时，将被放入一个等待队列，并在下一个时间片重新调度。
这种算法能够保证每个作业都能获得一定的执行时间，但不能很好地兼顾作业的响应时间。
5.最短剩余时间(SRT)算法：最短剩余时间算法是在短作业优先算法的基础上进行优化得到的。
在该算法中，系统会根据当前作业的执行时间和剩余执行时间来选择下一个要执行的作业。
这种算法能够更加准确地估计作业的完成时间，从而提高系统的响应时间和吞吐量。
除了以上几种常见的作业调度算法，还有很多其他的算法可以根据系统的特点和需求进行选择和优化，如最短作业优先(SJN)算法、优先级调度算法、多级反馈队列调度算法等。
作业调度算法
XI`AN TECHNOLOGICAL UNIVERSITY 实验报告西安工业大学实验报告一、实验目的进程调度是处理机管理的核心内容。
本实验要求用高级语言编写模拟进程调度程序，以便加深理解有关进程控制快、进程队列等概念，并体会和了解优先级算法的具体实施办法。
二、实验原理由于在单道批处理系统中，作业一投入运行，它就占有计算机的一切资源直到作业完成为止，因此调度作业时不必考虑它所需要的资源是否得到满足，它所占用的 CPU时限等因素。
1.先来先服务算法：按照作业提交给系统的先后顺序来挑选作业，先提交的先被挑选。
2.最短作业优先算法：是以进入系统的作业所提出的“执行时间”为标准，总是优先选取执行时间最短的作业。
3.优先级作业优先算法：是以进入系统的作业所提出的“优先级”为标准，总是优先选取优先级小的作业。
三、实验步骤、数据记录及处理实验步骤：1. 先定义一个结构体，在主函中先调用input()输入函数，在input()输入函数中，依次按着提示输入数据。
三种作业调度算法分别在三个子函数中执行：分别使用了fcfs(pc,i);short_in(pc,i);psa(pc,i);三个函数分别实现先来先服务算法、短作业优先算法和优先级算法。
这里先把段作业优先的思路理一理。
在短作业优先调度算法函数short_in()中，按照短作业优先调度的算法规则，每个作业完成后，在其完成时间前提交的作业中，运行时间最短的作业程序优先计算，在所有的作业都执行执行完后，程序再算出这种算法的平均周转时间和平均带权周转时间，并将所有的作业按其执行的顺序进行排序；代码实现（c语言）：#include<stdio.h>#include<stdlib.h>#define MAX_SIZE 100typedefstruct_PCB{int pid; //进程号int serve_time;//服务时间int com_tim; //到达时间int pri;//优先级int finish_time;//完成时间float zh_tim; //周转时间float dzhi_time;//带权周转时间}PCB;void swap(PCB *p,PCB *s){PCBtmp = *p;*p= *s ;*s = tmp;}void sort_cm(PCB *p,int len){for(int i = 0;i<len-1;i ++){for(int j = 0;j<len-1-i;j ++){if(p[j].com_tim>p[j+1].com_tim){swap(&p[j],&p[j+1]);}}}}void sort_serv(PCB *p,int start,int end){for(int i = start;i<end ;i ++){for(int j = start ;j<end;j ++){if(p[j].serve_time>p[j+1].serve_time){swap(&p[j],&p[j+1]);}}}}void sort_pri(PCB *p,int start,int end){for(int i = start;i<end ;i ++){for(int j = start ;j<end;j ++){if(p[j].pri>p[j+1].pri){swap(&p[j],&p[j+1]);}}}}void fcfs(PCB *p ,int len)//先来先服务{int i = 0;sort_cm(p,len);p[0].finish_time = p[0].serve_time ;p[0].zh_tim = p[0].finish_time - p[0].com_tim;p[0].dzhi_time = p[0].zh_tim / p[0].serve_time;p[0].pri = 1;while(i<len-1){i ++;p[i].finish_time = p[i].serve_time + p[i-1].finish_time;p[i].zh_tim = p[i].finish_time - p[i].com_tim;p[i].dzhi_time = p[i].zh_tim / p[i].serve_time;p[i].pri = 1;}}void short_in(PCB *p ,int len)//短作业优先{int i = 1;int k =0;int count = 0;sort_cm(p,len);p[0].finish_time = p[0].serve_time ;p[0].zh_tim = p[0].finish_time - p[0].com_tim;p[0].dzhi_time = p[0].zh_tim / p[0].serve_time;p[0].pri = 1;k = 0;while(i<len){for(int j = i;j<len;j ++){if(p[k].finish_time>= p[j].com_tim){count ++;}}sort_serv(p,i,i+count-1);while(count>0){p[i].finish_time = p[i].serve_time + p[k].finish_time;p[i].zh_tim = p[i].finish_time - p[i].com_tim;p[i].dzhi_time = p[i].zh_tim / p[i].serve_time;p[i].pri = 1;k = i;i ++;count --;}count = 0;}}void psa(PCB *p ,int len)//优先级是算法{int i = 1;int k =0;int count = 0;sort_cm(p,len);p[0].finish_time = p[0].serve_time ;p[0].zh_tim = p[0].finish_time - p[0].com_tim;p[0].dzhi_time = p[0].zh_tim / p[0].serve_time;k = 0;while(i<len){for(int j = i;j<len;j ++){if(p[k].finish_time>= p[j].com_tim){count ++;}}sort_pri(p,i,i+count-1);while(count>0){p[i].finish_time = p[i].serve_time + p[k].finish_time;p[i].zh_tim = p[i].finish_time - p[i].com_tim;p[i].dzhi_time = p[i].zh_tim / p[i].serve_time;k = i;i ++;count --;}count = 0;}}void show(PCB *p ,int len){printf("\n");printf("进程号到达时间服务时间优先级完成时间周转时间带权周转时间\n ");for(int i = 0; i<len ; i ++){printf(" %2d %9d %9d %7d %10d %9.2f %9.2f\n",p[i].pid,p[i].com_tim,p[i].serve_ time,p[i].pri,p[i].finish_time,p[i].zh_tim,p[i].dzhi_time);}printf("\n");}void input(PCB *pc){int i = 0;int h = 0;int m = 0;printf("请输入要输入的进程数量\n");scanf("%d",&h);printf("如果逆选择的是短作业和先来先服务，那么你的优先级默认\n");printf("请输入进程号、到达时间、完成时间：格式如下（进程号-到达时间-服务时间-优先级）\n");while(h> 0){scanf("%d-%d-%d-%d",&pc[i].pid,&pc[i].com_tim,&pc[i].serve_time,&pc[i].pri);fflush(stdin);i ++;h --;}printf("请输入你要选择的算法：：先来先服务算法2：短作业优先算法3：优先级算法\n");scanf("%d",&m);switch(m){case 1:fcfs(pc,i);printf("先来先服务的进程列表：\n");break;case 2:short_in(pc,i);printf("短作业优先的进程列表：\n");break;case 3:psa(pc,i);printf("优先级的进程列表：\n");break;default:printf("你输入的有误\n");break;}show(pc,i);}int main(){PCBpc[MAX_SIZE] ;input(pc);return 0;}测试结果：1、先来先服务：2、短作业优先3、优先级算法。
作业（进程）调度算法
作业（进程）调度算法
（1）先来先服务调度算法（FCFS）（作业、进程调度）：算法简单，但效率较低；有利于长作业，但对短作业不利，有利于CPU繁忙型作业，不利于I/O繁忙型作业。
（2）短作业优先调度算法（SJF）（作业）：运⾏时间短的作业优先执⾏，该算法对长作业不利，易造成“饥饿”问题，即长作业由于优先级低可能长期得不到处理。
（3）时间⽚轮转调度算法（进程调度）：
时间⽚的⼤⼩对系统性能影响很⼤，如果时间⽚⾜够⼤，以⾄于所有的进程都能在⼀个时间⽚内执⾏完毕，则退化为FCFS算法，如果时间⽚很⼩，那么处理机在进程间频繁切换，处理机真正⽤于运⾏⽤户进程的时间将减少。
时间⽚的长短由：系统的响应时间、就绪队列中的进程个数和系统的处理能⼒决定。
（4）优先级调度算法（作业、进程调度）：根据进程优先级决定运⾏的进程
（5）⾼响应⽐优先调度算法（作业调度）：响应⽐ = 1 + 作业等待时间/估计运⾏时间重点内容
（6）多级队列调度算法（进程调度）：对多个就绪队列设计不同的调度算法
（7）多级反馈队列调度算法：（UNIX调度⽤这个）。
作业调度算法的平均周转时间T和平均带权周转时间W。
1、有三个批处理作业，第一个作业10:00到达，需要执行2小时；第二个作业在10:10到达，需要执行1小时；第三个作业在10:25到达，需要执行25分钟。
分别采用先来先服务，短作业优先和最高响应比优先三种调度算法，各自的平均周转时间是多少？解：FCFS：执行顺序1->2->3，平均周转时间为 (120+170+180)/3=156.7分=2.61小时SJF：执行顺序1->3->2，平均周转时间为 (120+195+120)/3=145分=2.42小时HRF：执行顺序1->3->2，平均周转时间为(120+195+120)/3=145分=2.42小时2、在一单道批处理系统中，一组作业的提交时刻和运行时间如下表所示。
试计算一下三种作业调度算法的平均周转时间T和平均带权周转时间W。
（1）先来先服务；（2）短作业优先（3）高响应比优先作业提交时刻和运行时间表解：用T表示周转时间（运行时间+等待时间【开始时间-提交时间】），用W表示带权周转时间(周转时间/运行时间)FCFS的作业调度情况如下：SJF的作业调度情况如下：高响应比优先的作业调度情况如下：（响应比=周转时间/运行时间，选择响应比最大的）3、设系统中有3种类型的资源（A，B，C）和5个进程（P1，P2，P3，P4，P5），A资源的数量为17，B资源的数量为5，C资源的数量为20。
在T0时刻系统状态表如下表所示。
T0时刻系统状态（1）T0时刻是否为安全状态？若是，请给出安全序列。
（2）在T0时刻若进程P2请求资源（0,3,4），是否能实施资源分配？为什么？（3）在（2）的基础上，若进程P4请求资源（2,0,1），是否能实施资源分配？为什么？（4）在（3）的基础上，若进程P1请求资源（0,2,0），是否能实施资源分配？为什么？解：（1）在To时刻存在一个安全序列{P5,P4,P3,P2,P1}，故该状态时安全的。
（2）在To时刻因进程T2的请求资源（0,3,4）>剩余资源数（2,2,3），所以不能分配。
操作系统实验报告作业调度
操作系统实验报告作业调度操作系统实验报告：作业调度引言：操作系统是计算机系统中最核心的软件之一，它负责管理计算机的资源，为用户提供良好的使用环境。
在操作系统中，作业调度是非常重要的一部分，它决定了计算机如何合理地分配和调度各个作业的执行顺序，以提高计算机的效率和性能。
本实验报告将介绍作业调度的概念、调度算法以及实验结果。
一、作业调度的概念作业调度是指根据一定的策略和算法，将就绪队列中的作业按照一定的顺序分配给处理器，使得计算机系统能够充分利用资源，提高系统的吞吐量和响应时间。
作业调度的目标是实现公平性、高效性和平衡性。
二、作业调度的算法1. 先来先服务（FCFS）调度算法FCFS调度算法是最简单的调度算法之一，它按照作业的到达顺序进行调度，先到达的作业先执行。
这种算法的优点是简单易实现，但是可能会导致长作业等待时间过长，造成资源浪费。
2. 最短作业优先（SJF）调度算法SJF调度算法是根据作业的执行时间来进行调度，执行时间短的作业先执行。
这种算法能够最大程度地减少平均等待时间，提高系统的响应速度，但是可能会导致长作业长时间等待。
3. 优先级调度算法优先级调度算法是根据作业的优先级来进行调度，优先级高的作业先执行。
这种算法可以根据不同的需求设置不同的优先级，但是可能会导致低优先级的作业长时间等待。
4. 时间片轮转调度算法时间片轮转调度算法是将处理器的执行时间划分为多个时间片，每个作业在一个时间片内执行，时间片用完后，将处理器分配给下一个作业。
这种算法可以实现公平性，但是可能会导致长作业等待时间过长。
三、实验结果与分析在本次实验中，我们使用了不同的作业调度算法，并对其进行了性能测试。
测试结果显示，FCFS算法在平均等待时间方面表现较差，而SJF算法和优先级调度算法在平均等待时间方面表现较好。
时间片轮转调度算法能够实现公平性，但是可能会导致长作业等待时间过长。
结论：作业调度是操作系统中的重要组成部分，合理的作业调度算法能够提高计算机系统的效率和性能。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
第二讲作业调度算法主讲教师：张新彩
3.2 作业调度算法
3.2.1 先来先服务算法
3.2.2 短作业 / 进程优先算法
3.2.3 优先级调度算法
3.2.4 高响应比优先调度算法
3.2.1 先来先服务算法
▪适用于作业调度
•从后备作业队列中选择一个或多个最先进入的作业，将
它们调入内存，为它们分配资源、创建进程，然后放入
就绪队列。
▪适用于进程调度
•从就绪进程队列中选择一个最先进入的进程，为之分配
处理机，使之投入运行；直到运行完成或阻塞，才会让
出处理机。
3.2.1 先来先服务算法
4
平均周转时间为（4+6+10+11+14）/5=9
作业A 、B 、C 、D 、E 分别在0、1、2、3、4时刻到达，需要的服务时间分别为4、3、5、2、4。
请用先来先服务算法计算它们的完成时间、周转时间、带权周转时间和平均周转时间。
作业 名 到达 时间 服务 时间 开始执 行时间 完成 时间 周转 时间 带权周 转时间
A
4
B 1 3
C 2 5
D 3 2
E 4 4 4 7 12 14 1
2 2 5.5 0 4 7 12 4 6 10 11 18 3.5 14
14 简单易实现，有利于长作业，不利于短作业
3.2.2 短作业 / 进程优先算法
▪短作业优先（SJF）
•从后备队列中选择一个或多个估计运行时间最短的作业
调入内存。
▪短进程优先（SPF）
•从就绪队列中选出一个估计运行时间最短的进程，将处
理机分配给它，使它立即执行。
3.2.2 短作业 / 进程优先算法
6
平均周转时间为（4+3+8+9+16）/5=8
作业 名
到达 时间
服务 时间
开始执 行时间
完成 时间
周转 时间
带权周 转时间
作业A 、B 、C 、D 、E 分别在0、1、2、3、4时刻到达，需要的服务时间分别为4、3、5、2、4。
请用短作业优先算法计算它们的完成时间、周转时间、带权周转时间和平均周转时间。
4 1 0 4 6 1.
5 4 3 9
8/3 6 8 13 9/4 9 9 18 16/5
13 16 D 3 2 B 1 3 E 4 4
C 2 5 A 0 4
3.2.3 优先级调度算法
▪适用于作业调度
•从后备队列中选择若干个优先权最高的作业装入内存。
▪适用于进程调度
•根据进程的紧迫程度赋予每个进程一个优先权，选择就
绪队列中一个优先权最高的进程投入执行。
3.2.3 优先级调度算法
▪1. 优先级调度算法的类型
•（1）非抢占式优先权调度算法
▪把CPU分配给优先权最高的进程后，运行直至完成或发生某事件
而阻塞时，才将CPU分配给其他进程。
•（2）抢占式优先权调度算法
▪在执行期间出现了优先权更高的进程，系统将暂停当前进程，并
将CPU分配给新到的优先权最高的进程。
3.2.3 优先级调度算法
抢占的原则有：
•优先权原则
•短作业（进程）优先原则
•时间片原则
▪2. 优先权的类型
•（1）静态优先权
▪是在创建进程时确定的，且在进程的整个运行期间保持不变。
•（2）动态优先权
▪优先权可以随进程的推进或等待时间的增加而改变。
3.2.3 优先级调度算法
t(等待)
优先权
t(运行)
优先权
3.2.3 优先级调度算法
平均周转时间为（4+4+11+15+15）/5=49/4 进程A 、B 、C 、D 、E 分别在0、1、2、3、4时刻到达，需要的服务时间分别为4、3、5、2、4，优先数分别为2、4、3、5、1，规定优先数越小，优先级越高，请用非抢占式优先级算法计算各进程的完成时间、周转时间和平均周转时间。
进程 名 到达 时间 服务 时间 开始执 行时间 完成 时间 周转
时间
4
16
13
18 0 13 8 16 4 15 11 15
8
4 4 A 0 4 E 4 4 C 2
5 B 1 3 D 3 2
▪思想：优先级随着等待时间的增加而提高。
▪优先级的变化规律为：
▪优点：照顾短作业（进程）；考虑到达次序；兼顾长作业（进程）
3.2.4 高响应比优先调度算法
服务时间服务时间等待时间响应比+=
3.2.4 高响应比优先调度算法
进程A 、B 、C 、D 、E 分别在0、1、2、3、4时刻到达，需要的服务时间分别为4、3、5、2、4。
请用高响应比优先调度算法计算各进程的完成时间、周转时间和平均周转时间。
平均周转时间为（4+6+6+12+14）/5=42/5 进程
名 到达 时间 服务 时间 开始执 行时间 完成 时间 周转 时间
4
14 9
18 0 9 7 14 4 12 6 14
7
4 6 A 0 4 B 1 3 D 3 2 C 2
5 E 4 4
本节小结
▪1.理解每种调度算法的思想、特点
▪2.掌握使用各种调度算法完成调度的计算
思考
静态优先级和动态优先级的优缺点？。