[处理机调度实验报告1]处理机调度分级

深圳 大学实 验报告

　课程名称：

　操作系统

　实验项目名称：

　处理机调度

　学院：

　计算机与软件学院

　专业：

　软件工程

　指导教师：

　报告人：学号：

　班级：

　实验时间：

　2013年 5月7日

　实验报告提交时间：

　2013年 5月22日

　教务处制

　一、实验目的与要求：

　实验目的：模拟在单处理器多进程操作系统的 CPU调度。帮助学生掌握多种CPU调度 算法的知识原理和运作机制。本实验为模拟实验，不要求实现真正的进程创建与进程 调度。主要实现各种调度算法。实验要求：

　1、 阅读理解例程，掌握例程的运作流程。运行例程，理解先来先服务算法的调度原理 和运行结果。2、 参考先来先服务算法，尝试实现其他四种调度算法：短作业优先、高响应比、时间 片轮转、多级反馈队列。要求至少实现一种算法。a） 除了多级反馈队列，其他算法采用非抢占调度

　b） 短作业优先算法使用例题一数据或程序内置数据，要求运行结果给出调度顺

　序、完成时间、周转时间、带权周转时间

　c） 高响应比算法使用例题二的数据，要求运行结果给出调度顺序、完成时间、周 转时间、带权周转时间d） 时间片轮转算法可以使用程序内置数据，要求运行结果给出每个时间片是被哪 个进程使用，每个进程完成时，要修改状态并输出提示。e） 多级反馈队列算法使用例题三的数据，要求运行结果给出正确的进程调度顺序 和过程描述。二、方法、步骤：（说明程序相关的算法原理或知识内容，程序设计的思路和方法，可以用流程图 表述，程序主要数据结构的设计、主要函数之间的调用关系等 ）先来先服务算法：

　按到达时间先后，选择最先来的作业最先执行

　实现思想：

　对作业的到达时间按大小进行排序，然后按顺序执行

　短作业优先算法：

　在后备队列中，选择服务时间最短的作业最先执行 实现思想：

　对作业按到达时间排序，接着对到达的作业，即后备队列中的作业按服务时间 排序，取服务时间最小的作业最先执行高响应比算法：

　对作业的优先权（响应时间/要求服务时间）进行计算，对优先权最高的最先执 行 实现实现：计算后备队列中作业的优先权，并排序，优先权最高的最先执行

　时间片轮转算法：

　将所有就绪进程按先来先服务排成队列，把 CPU分配给队首进程，进程只执行 一个时间片，时间片用完后，将已使用时间片的进程送往就绪队列的末尾，分配处理 机给就绪队列中下一进程 实现思想：将作业按到达时间排序，在后备队列中选择第一个作业，把 CPU分配给它，执 行一个时间片，时间片用完后，将作业送往后备队列的末尾，把 CPU分配给下一个作 业，直到所有作业完成多级反馈队列调度算法：

　设置多个就绪队列，各个队列优先级逐个降低，各个队列时间片逐个增加，优 先级越高的队列执行时间片就越短，一般时间片按倍增规则，每个新进程首先进入第 一个队列，遵循FCFS,在当前队列的时间片内，进程若能完成，退出，进程若未完成， 降级到第二个队列，同样遵循 FCFS依次类推，若在第二个队列的时间片内仍未完成， 再降级到第三个队列…… 实现思想：设置多个就绪队列，各个队列优先级逐个降低，各个队列时间片逐个增加，优 先级越高的队列执行时间片就越短，一般时间片按倍增规则， 例如，第二队列的时间片要比第一个队列的时间片长一倍， ……，第i+1个队列的时间片要比第i个队列的时

　间片长一倍，整合了时间片、 FCFS、优先级三种机制。

　三?实验过程及内容：(对程序代码进行说明和分析，越详细越好，代码排版要整齐，可读性要高 )#include "stdio.h"

　#include<stdlib.h>

　〃#include<conio.h>

　#include<time.h>

　#include<math.h>

　〃#define NULL 0

　#define getpch(type)(type*)malloc(sizeof(type))typedef struct pcb PCB;

　struct pcb{ //定义进程控制块PCB

　int id; //标示符

　char name[10]; II 名称

　int time_start; 〃到达时间

　int time need; II服务时间

　〃剩余运行时间II

　〃剩余运行时间

　II已使用时间

　//进程状态

　int time_used; char state;

　}；

　II**************** 系统函

　void _sleep(int n)

　{

　clock_t goal; goal=(clock_t)n*CLOCKS_PER_SEC+clock(); while(goal>clock());}

　char _keygo()

　{ _

　char c; printf("按任意键继续……\n"); c=getchar(); return c;}

　用户函数//****************** int time_unit=2;用户函数

　int num=5; //实际进程数量

　PCB pcbdata[10]={

　〃例程内置数据

　{1000,"A",0,4,4,0,'R'},

　{1001,"B",1,3,3,0,'R'},

　{1002,"C",2,5,5,0,'R'},

　{1003,"D,,,3,2,2,0,'R'},

　{1004,"E",4,4,4,0,'R'}, };

　int num1=4;

　PCB pcbdata1[10]={

　〃例题一数据

　{1000,"Job1",1,9,9,0,'R'}, {1001,"Job2",1,16,16,0,'R'},{1002,"Job3",1,3,3,0,'R'},

　{1003,"Job4",1,11,11,0,'R'}, }; int num2=4; PCB pcbdata2[10]={〃例题二数据

　{1000,"P1",10,8,8,0,'R'},

　{1001,"P2",12,12,12,0,'R'}, {1002,"P3",14,4,4,0,'R'},,"P4",

　};

　int num3=4;

　PCB pcbdata3[10]={

　〃例程三数据

　{1000,"A",0,7,7,0,'R'},

　{1001,"B",5,4,4,0,'R'},

　{1002,"C",7,13,13,0,'R'}, {1003,"D",12,9,9,0,'R'},}；

　int ready[10]; 〃就绪队列，存放进程在 pcbdata中的位置

　int order[10]; //记录排序使用哪个数值作为排序对象

　void intput()

　{

　int i;

　printf("进程总数为：");

　scanf("%d",&num);

　for(i=0;ivnum;i++)

　{

　pcbdata[i].id=1000+i;

　printf("输入第%d个进程名：",i+1);

　scanf("%s",&pcbdata[i].name);

　printf("输入第%d个进程到达时间：",i+1); scanf("%d",&pcbdata[i].time_start);printf("输入第%d个进程服务时间：",i+1); scanf("%d",&pcbdata[i].time_need); pcbdata[i].time_left=pcbdata[i].time_need; printf("\n");pcbdata[i].time_used=0; pcbdata[i].state='R';}

　} void FCFS() {

　//**************调度函数

　//*

　*************

　调度函数

　int i,j,temp; double k; for(i=0;i<num;i++) {order[i]=pcbdata[i].time_start; ready[i]=i;}

　for(i=0;i<num;i++) 〃按到达时间排序

　if(order[i]>order[j])

　{

　temp=order[i]; order[i]=order[j]; order[j]=temp; temp=ready[i]; ready[i]=ready[j]; ready[j]=temp;}

　}

　printf("---先来先服务算法调度：非抢占，无时间片---\n");

　temp=pcbdata[ready[0]].time_start;

　for(i=0;i<num;i++)

　{

　printf("第%d 个进程--%s,",i+1,pcbdata[ready[i]].name);printf("本进程正在运行 ");

　_sleep(1)j

　printf("运行完毕 \n");

　temp+=pcbdata[ready[i]].time_need; j=temp-pcbdata[ready[i]].time_start; k=(float)j/pcbdata[ready[i]].time_need;printf("完成时间--%d,周转时间--%d,带权周转时间--%.1f\n",temp,j,k); } printf(" 所有进程调度完毕 \n");}

　void SJF()

　{

　int i,j,temp,l,temp_num;

　double k;

　int time=0;

　for(i=0;i<num1;i++)

　{

　order[i]=pcbdata1[i].time_start; ready[i]=i;} for(i=0;i<num1;i++) //按到达时间排序

　for(j=i+1;j<num1;j++)

　{

　if(order[i]>order[j])

　{ temp=order[i]; order[i]=order[j];

　order[j]=temp; temp=ready[i]; ready[i]=ready[j]; ready[j]=temp;}

　}

　printf("---短作业算法调度：非抢占，无时间片---\n");

　int t_ready[10]; //就绪队列，存放进程在 pcbdata中的位置int t_order[10]; //记录排序使用哪个数值作为排序对象

　for(i=0;i<num1;i++)

　{

　t_order[i]=pcbdata1[ready[i]].time_need;//]艮务时间作为排序对象 t_ready[i]=ready[i];} _

　time=order[0];

　for(l=0;lvnum1;l++){

　〃判断到达的进程数，用temp_num存放

　for(i=0;i<num &&pcbdata1[ready[i]].time_startv=time;i++) temp_num=i+1;//把到达的进程按服务时间大小进行排序

　for(i=0;ivtemp_num;i++) for(j=i+1;jvtemp_num;j++) { _if(t_order[i]>t_order[j]&&t_order[j]!=0||t_order[i]==0)殳 _ _ 一 一

　temp=t_order[i]; t_order[i]=t_order[j]; t_order[j]=temp; temp=t_ready[i]; t_ready[i]=t_ready[j]; t_ready[j]=temp;} _

　}

　printf("第%d 个进程--%s,",l+1,pcbdata1[t_ready[0]].name); printf("正在运行 ");_sleep(1)j

　printf("运行完毕 \n");

　time+=pcbdata1[t_ready[0]].time_need;

　j=time-pcbdata1[t_ready[0]].time_start; k=(float)j/pcbdata1[t_ready[0]].time_need; t_order[0]=0;printf("完成时间--%d,周转时间--%d,带权周转时间

　--%.1f\n",time,j,k);

　} printf(" 所有进程调度完毕 \n");

　}

　void HRF()

　{

　int i,j,temp,l,temp_num; double k;

　int time=0;

　for(i=0;ivnum2;i++)

　{

　order[i]=pcbdata2[i].time_start; ready[i]=i;} for(i=0;i<num2;i++) //按到达时间排序

　for(j=i+1;j<num2;j++)

　{

　if(order[i]>order[j])

　{ temp=order[i]; order[i]=order[j]; order[j]=temp; temp=ready[i]; ready[i]=ready[j]; ready[j]=temp;}

　}

　printf("---高响应比算法调度：非抢占，无时间片---\n"); int t_ready[10];int t_order[10]; for(i=0;i<num2;i++)

　{

　t_order[i]=1; t_ready[i]=ready[i];

　} _

　time=order[0]; for(l=0;l<num2;l++){

　〃判断到达进程数

　for(i=0;i<num &&pcbdata2[ready[i]].time_startv=time;i++) temp_num=i+1;for(i=0;ivtemp_num;i++) //计算已到达进程的优先权

　{ if(t order[i])

　t_order[i]=(time-pcbdata2[t_ready[i]].time_start+ pcbdata2[t_ready[i]].time_need)/pcbdata2[t_ready[i]].time_need;} for(i=0;ivtemp_num;i++) // 按优先权排序

　for(j=i+1;jvtemp_num;j++)

　{

　if(t_order[i]vt_order[j])

　{ 一 一

　temp=t_order[i]; t_order[i]=t_order[j]; t_order[j]=temp; temp=t_ready[i]; t_ready[i]=t_ready[j]; t_ready[j]=temp;} _

　}

　printf("第%d 个进程--%s,",l+1,pcbdata2[t_ready[0]].name);printf("正在运行 ");

　_sleep(1);

　printf("运行完毕 \n");

　time+=pcbdata2[t_ready[0]].time_need;

　j=time-pcbdata2[t_ready[0]].time_start; k=(float)j/pcbdata2[t_ready[0]].time_need; t_order[0]=0;printf("完成时间--%d,周转时间--%d,带权周转时间 --%.1f\n",time,j,k);}

　printf(" 所有进程调度完毕 \n");

　}

　void Timeslice()

　{

　int i,j,temp,l,temp_num;

　double k;

　int time=0;

　int done=0;

　for(i=0;i<num;i++)

　{

　order[i]=pcbdata[i].time_start;

　ready[i]=i;

　} for(i=0;i<num;i++) //按到达时间排序

　for(j=i+1;jvnum;j++)

　if(order[i]>order[j])

　{

　temp=order[i]; order[i]=order[j]; order[j]=temp; temp=ready[i]; ready[i]=ready[j]; ready[j]=temp;}

　}

　printf("---时间片轮转算法调度：非抢占，时间片大小为 2---\n");int t_ready[10];

　for(i=0;i<num;i++)

　{

　t_ready[i]=ready[i];

　} time=order[0]; for(l=0;done<num;l++){

　〃判断到达的进程数

　for(i=0;i<num &&pcbdata[ready[i]].time_startv=time;i++) temp_num=i+1;if(time!=order[0]){

　〃将已使用时间片的进程，即第一个移到队列末尾

　for(i=1;ivtemp_num;i++){ temp=t_ready[i]; t_ready[i]=t_ready[i-1]; t_ready[i-1]=temp;}

　}

　if(pcbdata[t_ready[0]].state!='F'){

　printf(" 第 %d 个时间片被进程 %s 使 用，",l+1,pcbdata[t_ready[0]].name);printf("正在运行 \n ");

　_sleep(1);

　printf("时间片使用完，所需时间 %d,",pcbdata[t_ready[0]].time_left); time+=2;pcbdata[t_ready[0]].time_used+=2; pcbdata[t_ready[0]].time_left-=2; printf("使用时间 %d,还需时间 %d,",2,pcbdata[t_ready[0]].time_left);〃判断进程是否结束

　if(pcbdata[t_ready[0]].time_leftv=0){

　printf("进程 ％s 结束\n",pcbdata[t ready[0]].name);done++;

　pcbdata[t_ready[0]].state='F';

　} _

　else

　printf("进程 %s 就绪\n",pcbdata[t_ready[0]].name);}

　} printf(" 所有进程调度完毕 \n");

　}

　void MRLA()

　{

　int i,j,temp,l,temp_num,temp_num2; double k;int time=0; //系统时间

　int done=0; //已完成的进程

　int t_ready[10];

　int queue[10]; 〃进程对应的队列

　int qtime[10]; 〃进程对应的时间片

　for(i=0;ivnum3;i++)

　{

　order[i]=pcbdata3[i].time_start;

　ready[i]=i; queue[i]=1; qtime[i]=0;

　} for(i=0;i<num3;i++) 〃按到达时间排序

　for(j=i+1;j<num3;j++)

　{

　if(order[i]>order[j])

　{ temp=order[i]; order[i]=order[j]; order[j]=temp; temp=ready[i]; ready[i]=ready[j]; ready[j]=temp;}

　}

　printf("---多级反馈算法调度：抢占式，时间片大小为 2---\n");

　for(i=0;i<num3;i++)

　{

　t_ready[i]=ready[i];

　time=order[0]; for(l=0;done<num3;l++){

　〃判断到达的进程数

　for(i=0;i<num3&&pcbdata3[ready[i]].time_startv=time;i++) temp_num=i+1;if(time!=order[0]){ for(i=0;ivtemp_num;i++) II 按队列优先级排序 for(j=1;jvtemp_num-i;j++){ if(pcbdata3[t_ready[j-1]].state=='F'||(queue[j-1]>queue[j] && pcbdata3[t_ready[j]].state!='F')){ temp=queue[j-1]; queue[j-1]=queue[j]; queue[j]=temp;temp=t_ready[j-1];

　t_ready[j-1]=t_ready[j]; t_ready[j]=temp;temp=qtime[j-1];

　qtime[j-1]=qtime[j]; qtime[j]=temp;

　}

　}

　}

　if(pcbdata3[t_ready[0]].state!='F'){ printf("队列 %d 中的进程 %s 占用 CPU,",queue[0], pcbdata3[t_ready[0]].name);printf("正在运行 \n ");

　_sleep(1); if(!qtime[0]) //判断是否有未用完的时间片

　qtime[0]=pow(2,queue[0]);

　else printf("继续使用时间片，")； for(i=1;ivqtime[0];i++){

　time++;

　for(j=0;j<num3&&pcbdata3[ready[j]].time_startv=time;j++) temp_num2=j+1;〃判断是否有进程进入比本进程更高优先级的队列

　if(temp_num!=temp_num2&&queue[0]>queue[temp_num2-1]&& pcbdata3[t_ready[0]].time_left-i>0){ qtime[0]-=i;break;

　if(temp_num!=temp_num2&&queue[0]>queue[temp_num2-1]&&pcbdata3[t_read y[0]].time_left-i>0){printf("发生抢占，使用时间片%d，剩余时间片%d，返回队列尾部\n",i,qtime[0]);}

　else{

　printf("时间片使用完，所需时间%d,", pcbdata3[t_ready[0]].time_left);time++;

　pcbdata3[t_ready[0]].time_used+=pow(2,queue[0]); pcbdata3[t_ready[0]].time_left-=pow(2,queue[0]);if(pcbdata3[t_ready[0]].time_leftv=0){ printf("使用时间%d,还需时间%d,进程%s结束\n",qtime[0], pcbdata3[t_ready[0]].time_left,pcbdata3[t_ready[0]].name);done++;

　pcbdata3[t_ready[0]].state='F';

　} _

　else printf("使用时间%d,还需时间%d,进程%s进入队列%d就绪 \n",qtime[0],pcbdata3[t_ready[0]].time_left,pcbdata3[t_ready[0]].name,++queue[0]);qtime[0]=0;

　}

　} for(j=1;jvtemp_num2;j++){ //将执行的程序返回队尾排队temp=queue[j];

　queue[j]=queue[j-1]; queue[j-1]=temp;

　temp=qtime[j]; qtime[j]=qtime[j-1]; qtime[j-1]=temp;temp=t_ready[j];

　t_ready[j]=t_ready[j-1]; t_ready[j-1]=temp;} _

　}

　printf(" 所有进程调度完毕 \n");

　int main()

　{

　int i=0,sch=99; while(sch!=0) {printf("\n请选择其中一种调度算法：\n"); printf("(1)先来先服务 FCFS\n"); printf("(2)短作业优先 SJF\n");printf("(3)高响应比 HRF\n");

　printf("(4)时间片轮转 Timeslice\n"); printf("(5)多级反馈队列 MRLA\n");printf("(0)退出 \n");

　printf("请输入上述一个数字：")；

　scanf("%d", &sch);

　switch(sch)

　{

　case 1:FCFS();break;

　case 2:SJF();break;

　case 3:HRF();break;

　case 4:Timeslice();break;

　case 5:MRLA();break;

　case 0:printf('退出程序 \n");break;

　}

　}

　_keygo(); return 0;

　}

　void dis_pcb(PCB * pr)

　{ _ printf("%s 的 PCB:\n",pr->name); printf("标识符--%d,状态--%c,到达时间--%d\n",pr->id,pr->state,pr->time_start); printf(" 服务时间--%d,剩余运行时间--%d,已用时间 --%d\n",pr->time_need,pr->time_left,pr->time_used);printf(" \n");

　}

　void dis_pcb_all()

　{ 一 一

　int i;

　printf("***当前所有进程状态******\n");

　for(i=0;i<num;i++)

　dis_pcb(&pcbdata[i]);

　L

　void dis_ready()

　{ _

　int i;

　printf("当前就绪队列为：");

　for(i=0;ivnum-1;i++) printf("%s--",pcbdata[order[i]].name);printf("%s\n",pcbdata[order[i]].name);

　}

　zhouj i ancan?zhouj i ancan-PC /2011150368 $ - /aBI回匚-/201115036a四、实验结论：（提供运行结果，对结果进行探讨、分析、评价，并提出结论性意见和改进想法） 先来先服务算法 FCFS:优点：实现简单，算法开销小，有利于长时间作业（进程） 缺点：不利于短时间作业（进程）O'E i 口 E

　zhouj i ancan?zhouj i ancan-PC /2011150368 $ - /a

　B

　I回

　匚-/201115036a

　四、实验结论：（提供运行结果，对结果进行探讨、分析、评价，并提出结论性意见和改进想法） 先来先服务算法 FCFS:

　优点：实现简单，算法开销小，有利于长时间作业（进程） 缺点：不利于短时间作业（进程）

　O'E i 口 E i CJEO'E 一有

　日

　炸进斛进尊尊转. 谢具本酣本聘本周本周本周 ybB* JH J- J J J * J

　-繭-A空-B仆-C12T14-E18进 述月 一一 -一一 一一一 -一一rm

　矍时程时程曰

　鸟seR

　调cfjf-S

　T务先HRP转队 搭福燼勞課課課畧一

　请 0(2(3(4(5(0请蔓一蚩_蚩_ 畫矍元一

　匕r 呂 匕L O匕1-5呂5 一 E 耳 ayt ■耳- 一完「完弋完-2完-5完-3 丄gr-1-「-2.- 丁.」「"」「 间运SJ-运B1-运挖运加运推 !▼ J % ■- 1 - -二.? L; ? n~T 寸一 17 -专

　HwvcnH■车

　无2转穆【包周【周一 为周【周-权-权【权 怆f■权一T-^T'带T-带一厂带一 非运岸肖运10运11运14 ;在『在y在一在一在一4- 1廈器肚福需庇fflE 卜度 调

　，程

　短作业优先算法 SJF:

　优点：有利于短作业或短进程

　缺点：导致长作业或进程长时间不被调度，不能保证实时性，执行时间一般基于用户估算，准确性 不足高响应比算法HRF:

　高响应比优先调度算法的优点：

　对于等待时间相同的时候，服务时间愈短则优先权愈高，算法有利于短作业 ；

　对于服务时间相同的时候，等待时间愈长其优先权愈高，算法实现的是先来先服务 ；

　对于长作业，作业的优先级可以随等待时间的增加而提高，当其等待时间足够长时，其优先级便可 升到很高保证能获得处理机。缺点：每次调度前都要计算优先权，增加系统开销。

　IB时B(0〕退 H 请输人 —t请选择其中一种调度算法;(1) "

　IB

　时

　B

　(0〕退 H 请输人 —t

　请选择其中一种调度算法;

　(1) " ⑵

　(3) ⑷日

　高响应比HRF

　第昇跚 第课輪 时砺 第8个时间 时1$片 第11个日1 曲呷 第13个日

　在时间片轮转算法中，时间片大小对系统性能有很大的影响，如选择很小的时间片将有利于短作 业，因为它能较快的完成，但会频繁的发生中断、进程上下文的切换，从而增加系统的开销；反 之，如选择较长的时间片，使得每个进程都能在一个时间片内完成，时间片轮转算法便退化为 FCFS算法，无法满足交互式用户的需求。

　g转Timeslice 贵队列MRLA

　时间片轮转算法 Timeslice:

　C -/2011150568

　时间片大小为込

　需时wt用时间z还需时间z进程蹴绪 ,正在运行

　需时间3使用时间N还需时间1.进程B就绪 Jffl正隹运行

　MW； 嚨时间5』蓮用时间z还需时间3,进程C就绪 祕逑程嗾就正在运行……

　一亠亠需时间生使用时间Z还需时间①进程牆束

　__ 正在运行……

　Wfro 时间2』使用时间N还需时间a进程D结束 碱卓程礙，正在运行…… 用完'一噜呷瘻髀字 还需时间Z进程E就绪 翼描乎離甯时间Z还需时间7进程B结束 定在运行……

　畫时间3使用时间2,还需时间1.进程C就绪 墨时i呕 使用时间z还需时间a进程e结束 横耳 正在运存…… 篇體镯漏率鬱寸间1,使用时间占还需时间迸程C结束

　多级反馈队列算法 MRLA :

　匸-/2011150368

　zhouj iancan?zhouj i ancan-PC V2011150368 $?/a|请选择基中二f申调虞算法:

　（砸翻娜

　⑸多紡 请输人一

　扌轮转T-mesl ice 疋馈队列MRIA

　h~掙縫屈壇募威 抢占式1时间片大小为2— 队列臧鱷A占蔵巴JEfefefc-.-：■1巾申

　审￡1比八匚…—…亠?”…， 诵的迸程C占用C也 正在坯行……

　队歹骡

　「0

　队歹！

　鷹品完己所需时i班負用时间z还需时间氐进程趟入队列蹴绪

　「“占皤隸黒辐爲捅片1,返回队列尾部

　PU,正在运彳亍

　，所需时间4,使用时间占还需时间可进程B进入队列蹴绪

　队歹! 队员

　B 队列

　队列

　队歹!

　队列

　队列

　队列

　?A^cpuJlfer-;-:' L L _「二…]…. 用时间生时|可片使用完. 逻1B占用CPU,正注运〔二……

　硬用完，所需时间2,傅用时间4,还需时间吆进程B结東

　遴程D占用CPU,正在运花?一

　僅用完，所需时咸，傳用时间N还需时间亿进程瞪入队列2就绪 进程C占用CPU,正在逾……时间*还需时间加程C进入队那就绪 傳篇烈鲁需时備闕諒啊还需时间3」进程D进入队列3就绪 间甘偉用丸 所需时间1,0时间務还需时间7进程A结束 电櫃程站朋?正在镒…" 亠J「

　用时间Z还需时间11，进程C进入队列2就绪

　,所需时间瓦使用时间1,还需时间1,进程A进入队列3就绪

　忖旦片

　3中

　寸间

　Si ■ _ _

　由旬片使用芫'厮需月間点用时间&还需时间-1,进程C结束 ”3中曲进握D占用CPU,主右运卩 时间片使用完，所壷」* — . 一—「二—1 ： 一-所有撐錨度唾牟

　曲完上所需0?，?_

　至眩瞬鬻孺闊需畝还需时间弋进程D结束

　E -720111503^8

　zhon j i anc an@ zhouj i an c an~PC /2$ ■畑法ce 算11A 匱丫esRL 调帀卩.K 申卩￡ F T歹 T弟先HRF转队 时先业应宦腾艮r/Mk 1寸24511寸1寸2怡2寸1寸2_寸2寸3寸第寸3寸 选粢用)a序应日列疥日列日专列日列日列日列日列日列日列日 聘ICZlcgluKSKO请一队队队队队队队队队队队队备囂M第彎書亶暑書書一 <|'0]7囂農1鳖1豐理證嚅琶 5 u 冒pu间pu需pu需pu时pu需pu需pu需pu需pu需pu需pum 黑 ■ ■ ■ ■ 用犬罰仆用戶用F用戶用F.用戶用F用序匱 1A￡=^?S>宀S间砧兄站宀S完站宀S宀一SS& ? …J程用程用程时程用程用程用程用程用程用趕醫 ■间间中间中：^^^中间中间中间-E-s^ <±7<L+JHJ2kt 21J1XJ21J2XJ- 31J 3XJ 31J 一n~n八

　9 * ?

　■ ■

　八 r_T八 nn - -Hn 八 八 ftr 八 nn - An 八 nn 订B屢xax墨霽-征扌亚15^. JTH

　:」Jnn - -- I u ■ — — — — — — — UPU需阡卩日IHEPtm日田P鲁日IBER詈日兽日鲁日書P甯 F=度那所那时取所班所班書班所那所班所那所班所那所 与禺 at. at.冃片 at. 异 at. ttt.斤 ttt. t±t r斗e;

　多级反馈队列调度算法的性能：

　终端型作业用户一般能在第一队列完成，响应时间短，满足用户交互型需求；

　短批处理作业用户一般能在第二队列，至多第三队列可以完成，经历队列少，等待时间也少； 长批处理作业用户可能经过多个队列才能完成，但在每个队列都能够得到时间片的分配，不会出现 长时间不处理的情况。五、实验体会：（根据自己情况填写）

　通过本次实验，基本了解计算机 CPU对执行进程时的运作模式，掌握了先来先服务算法、短作业优先算法、高响应比算法、时间片轮转算法、多级反馈队列算法这五种 CPU调度算法，掌握了这五种算法的的基本原理和运作机制，以及其算法实现。通过对这五种算法的模拟实验，对这五 种调度算法有了更进一步的理解。指导教师批阅意见:

　完成了给定的所有调度算法，结果正确，过程完整，非常好。

　成绩评定:

　指导教师签字：

　2013 年 6 月 1 日

　备注:

相关关键词： 处理机 社区突发疫情处理机制 矛盾纠纷排查协调处理机制