华东交通大学操作系统实验二作业调度实验(含代码)

实验名称作业调度实验内容1、设计可用于该实验的作业控制块；2、动态或静态创建多个作业；3、模拟先来先服务调度算法和短作业优先调度算法。

3、调度所创建的作业并显示调度结果（要求至少显示出各作业的到达时间，服务时间，开始时间，完成时间，周转时间和带权周转时间）；3、比较两种调度算法的优劣。

实验原理一、作业作业(Job)是系统为完成一个用户的计算任务（或一次事物处理）所做的工作总和，它由程序、数据和作业说明书三部分组成，系统根据该说明书来对程序的运行进行控制。

在批处理系统中，是以作业为基本单位从外存调入内存的。

二、作业控制块J C B(J o b C o nt r o l Bl o ck)作业控制块ＪＣＢ是记录与该作业有关的各种信息的登记表。

为了管理和调度作业，在多道批处理系统中为每个作业设置了一个作业控制块，如同进程控制块是进程在系统中存在的标志一样，它是作业在系统中存在的标志，其中保存了系统对作业进行管理和调度所需的全部信息。

在JCB中所包含的内容因系统而异，通常应包含的内容有：作业标识、用户名称、用户帐户、作业类型(CPU 繁忙型、I/O 繁忙型、批量型、终端型)、作业状态、调度信息(优先级、作业已运行时间)、资源需求(预计运行时间、要求内存大小、要求I/O设备的类型和数量等)、进入系统时间、开始处理时间、作业完成时间、作业退出时间、资源使用情况等。

三、作业调度作业调度的主要功能是根据作业控制块中的信息，审查系统能否满足用户作业的资源需求，以及按照一定的算法，从外存的后备队列中选取某些作业调入内存，并为它们创建进程、分配必要的资源。

然后再将新创建的进程插入就绪队列，准备执行。

四、选择调度算法的准则1）．面向用户的准则(1) 周转时间短。

通常把周转时间的长短作为评价批处理系统的性能、选择作业调度方式与算法的重要准则之一。

所谓周转时间，是指从作业被提交给系统开始，到作业完成为止的这段时间间隔(称为作业周转时间)。

华中师范大学计算机科学系《操作系统》实验报告实验题目：进程调度学生姓名：日期：2011-12-9实验2进程调度进程完成，撤消该进程就绪队列首进程投入运行 时间片到，运行进程已占用CPU 时间+1 运行进程已占用CPU 时间已达到所需的运行时间 把运行进程插入到下一个队列的队尾插入新的进程开始 初始化PCB,输入进程信息 所有队列都为空 各进程按FCFS 原则排队等待调度 【实验目的】（1）通过编写程序实现进程或作业先来先服务、高优先权、按时间片轮转调度算法，使学生进一步掌握进程调度的概念和算法，加深对处理机分配的理解。

（2）了解Windows2000/XP 中进程（线程）的调度机制。

（3）学习使用Windows2000/XP 中进程（线程）调度算法，掌握相应的与调度有关的Win32 API 函数。

【实验内容】在Windows XP 、Windows 2000等操作系统下，使用的VC 、VB 、java 或C 等编程语言，利用相应的WIN32 API 函数，编写程序实现进程或作业先来先服务、高优先权、按时间片轮转调度算法。

【实验步骤、过程】（含原理图、流程图、关键代码，或实验过程中的记录、数据等）1、进程调度算法：采用多级反馈队列调度算法。

其基本思想是：当一个新进程进入内在后，首先将它放入第一个队列的末尾，按FCFS 原则排队等待高度。

当轮到该进程执行时，如能在该时间片内完成，便可准备撤离系统；如果它在一个时间片结束时尚为完成，调度程序便将该进程转入第二队列的末尾，再同样地按FCFS 原则等待调度执行，以此类推。

2、实验步骤:（1）按先来先服务算法将进程排成就绪队列。

（2）检查所有队列是否为空，若空则退出，否则将队首进程调入执行。

（3）检查该运行进程是否运行完毕，若运行完毕，则撤消进程，否则，将该进程插入到下一个逻辑队列的队尾。

（4）是否再插入新的进程,若是则把它放到第一逻辑队列的列尾。

（5）重复步骤（2）、（3）、（4），直到就绪队列为空。

作业调度一、实验目的1、对作业调度的相关内容作进一步的理解。

2、明白作业调度的主要任务。

3、通过编程掌握作业调度的主要算法。

二、实验内容及要求1、对于给定的一组作业, 给出其到达时间和运行时间，例如下表所示：2、分别用先来先服务算法、短作业优先和响应比高者优先三种算法给出作业的调度顺序。

3、计算每一种算法的平均周转时间及平均带权周转时间并比较不同算法的优劣。

测试数据workA={'作业名':'A','到达时间':0,'服务时间':6} workB={'作业名':'B','到达时间':2,'服务时间':50} workC={'作业名':'C','到达时间':5,'服务时间':20} workD={'作业名':'D','到达时间':5,'服务时间':10} workE={'作业名':'E','到达时间':12,'服务时间':40} workF={'作业名':'F','到达时间':15,'服务时间':8}运行结果先来先服务算法调度顺序:['A', 'B', 'C', 'D', 'E', 'F']周转时间:带权周转时间:短作业优先算法调度顺序:['A', 'D', 'F', 'C', 'E', 'B']周转时间:带权周转时间:1.响应比高者优先算法调度顺序:['A', 'D', 'F', 'E', 'C', 'B']周转时间:带权周转时间:五、代码#encoding=gbkworkA={'作业名':'A','到达时间':0,'服务时间':6,'结束时间':0,'周转时间':0,'带权周转时间':0}workB={'作业名':'B','到达时间':2,'服务时间':50}workC={'作业名':'C','到达时间':5,'服务时间':20}workD={'作业名':'D','到达时间':5,'服务时间':10}workE={'作业名':'E','到达时间':12,'服务时间':40}workF={'作业名':'F','到达时间':15,'服务时间':8}list1=[workB,workA,workC,workD,workE,workF]list2=[workB,workA,workC,workD,workE,workF]list3=[workB,workA,workC,workD,workE,workF]#先来先服务算法def fcfs(list):resultlist = sorted(list, key=lambda s: s['到达时间'])return resultlist#短作业优先算法def sjf(list):time=0resultlist=[]for work1 in list:time+=work1['服务时间']listdd=[]ctime=0for i in range(time):for work2 in list:if work2['到达时间']<=ctime:(work2)if len(listdd)!=0:li = sorted(listdd, key=lambda s: s['服务时间'])(li[0])(li[0])ctime+=li[0]['服务时间']listdd=[]return resultlist#响应比高者优先算法def hrrn(list):time=0resultlist=[]for work1 in list:time+=work1['服务时间']listdd=[]ctime=0for i in range(time):for work2 in list:if work2['到达时间']<=ctime:work2['等待时间']=ctime-work2['到达时间'](work2)if len(listdd)!=0:li = sorted(listdd, key=lambda s: (s['等待时间']+s['服务时间'])/s['服务时间'])(li[-1])(li[-1])ctime+=li[-1]['服务时间']listdd=[]return resultlist#调度顺序def shunxu(resultlist,miaoshu):print(miaoshu)ddsx=[]for work in resultlist:for d,x in ():if ('gb2312')==u'作业名':(x)#print ('gb2312')+":"+str(x)print(u'调度顺序:'+str(ddsx))turnaroundTime(resultlist)#平均周转时间及平均带权周转时间def turnaroundTime(resultlist):time=0for work in resultlist:work['结束时间']=work['服务时间']+timetime=work['结束时间']work['周转时间']=work['结束时间']-work['到达时间']work['带权周转时间']=work['周转时间'] / work['服务时间']zzsj=0dqzzsj=0for work in resultlist:zzsj+=work['周转时间']dqzzsj+=work['带权周转时间']print('周转时间:'+str(zzsj*len(resultlist)))print('带权周转时间:'+str(dqzzsj*len(resultlist))) print('')shunxu(fcfs(list1),'先来先服务算法')shunxu(sjf(list2),'短作业优先算法')shunxu(hrrn(list3),'响应比高者优先算法')。

操作系统实验报告作业调度操作系统实验报告：作业调度引言作业调度是操作系统中的重要部分，它负责管理和调度系统中的各种作业，以最大化系统资源的利用率和提高作业的执行效率。

在本次实验中，我们将探讨作业调度的基本原理和实现方法，并通过实验验证其效果。

实验目的本次实验的主要目的是通过实际操作，了解作业调度的基本原理和实现方法，掌握作业调度的相关算法，并通过实验验证其有效性。

实验内容1. 实现作业调度的基本算法在本次实验中，我们将实现作业调度的基本算法，包括先来先服务（FCFS）、最短作业优先（SJF）、优先级调度（Priority Scheduling）和多级反馈队列调度（Multilevel Feedback Queue Scheduling）等。

通过编写代码，模拟这些算法的执行过程，并观察它们的效果。

2. 实验验证我们将设计一些测试用例，通过模拟作业的执行过程，分别使用不同的作业调度算法，并比较它们的执行效果。

通过实验验证，我们将得出不同算法的优劣势，并分析其适用场景。

实验结果经过实验验证，我们得出以下结论：1. 先来先服务（FCFS）算法适用于作业执行时间相对均匀的情况，但可能会导致平均等待时间较长。

2. 最短作业优先（SJF）算法能够最大程度地减少平均等待时间，但可能会出现作业饥饿现象。

3. 优先级调度（Priority Scheduling）算法能够根据作业的优先级进行调度，适用于有明确优先级需求的情况。

4. 多级反馈队列调度（Multilevel Feedback Queue Scheduling）算法能够根据作业的执行情况动态调整优先级，适用于各种类型的作业。

结论作业调度是操作系统中的重要组成部分，不同的作业调度算法适用于不同的场景。

通过本次实验，我们深入了解了作业调度的基本原理和实现方法，掌握了不同算法的优劣势，并通过实验验证了它们的有效性。

这将对我们进一步深入学习操作系统和提高系统性能有着重要的意义。

西北农林科技大学信息工程学院实习报告课程操作系统学院信息工程专业年级软件151 学号2015012893 姓名张鑫周次第八周交报告时间2017.5.5 成绩实验二作业调度实验一. 目的要求：用高级语言编写和调试一个或多个作业调度的模拟程序，以加深对作业调度算法的理解。

二、实验内容：1、编写并调试一个单道处理系统的作业等待模拟程序。

作业等待算法：分别采用先来先服务（FCFS），最短作业优先（SJF）、响应比高者优先（HRN）的调度算法。

流程图如下：1、响应比高者优先算法流程图：开始初始化所有的JBC，使JBC按作业提交的时间的先后顺序排队时间量times=0先计算队列中所有的作业的响应比，总是西选择响应比最高的走也作为此刻要运行的作业，并修改相应的指针，更改时间量的值不空等待队列空？空计算并打印这组作业的平均周转时间及带权平均周转时间结束2、先来先服务调度算法流程图：3、短作业优先算法调度流程图：实验代码如下：#include<stdio.h> #include<stdlib.h> #include<string.h>struct jcb{char name[10];//作业名float arrtime;//提交时间float waitTime;//等待时间float startTime;//开始时间float runTime;//运行时间float finishTime;//完成时间float TAtime; //周转时间float TAWtimei;//带权周转时间float AvgTAtime,AvgTAWtimei;//平均周转时间；平均带权周转时间 float bi;//响应比};jcb JCB[100];int ReadFile(){int m=0;int i=0;FILE *fp; //定义文件指针fp=fopen("3.txt","r"); //打开文件if(fp==NULL){printf("File open error !\n");exit(0);}else{printf("作业名提交时间运行时间\n");while(!feof(fp)){fscanf(fp,"%s%f%f",&JCB[i].name,&JCB[i].arrtime,&JCB[i].runTime); //fscanf()函数将数据读入printf("\n%s%15f%12f",JCB[i].name,JCB[i].arrtime,JCB[i].runTime); //输出到屏幕i++;}fclose(fp); //关闭文件}m=i-1;return m;}//菜单void menu(){printf("\n\n |*************** 作业调度*************|\n");printf("|======================================|\n");printf(" | 0.退出|\n");printf(" | 1.先来先服务 (FCFS) 调度算法|\n");printf(" | 2.短作业优先 (SJF) 调度算法|\n");printf(" | 3.响应比高者优先 (HRRN) 调度算法 |\n");printf("|======================================|\n");}void displayone(float p,char *h,int i,int j){strcpy(h,JCB[i].name);strcpy(JCB[i].name,JCB[j].name);strcpy(JCB[j].name,h);p=JCB[i].arrtime;JCB[i].arrtime=JCB[j].arrtime;JCB[j].arrtime=p;p=JCB[i].runTime;JCB[i].runTime=JCB[j].runTime;JCB[j].runTime=p;p=JCB[i].startTime;JCB[i].startTime=JCB[j].startTime;JCB[j].startTime=p;p=JCB[i].finishTime;JCB[i].finishTime=JCB[j].finishTime;JCB[j].finishTime=p;}void displaytow(int i,int y){printf("\n");printf("作业%s先开始运行\n\n",JCB[0].name);float AvgCycleTime,AvgValueCycleTime,k=0,m=0;//AvgCycleTime为平均周转时间,AvgValueCycleTime为平均带权周转时间for(i=0;i<y;i++){JCB[0].startTime=JCB[0].arrtime;JCB[i].finishTime=JCB[i].startTime+JCB[i].runTime;//结束时间JCB[i+1].startTime=JCB[i].finishTime;JCB[i].waitTime=JCB[i].startTime-JCB[i].arrtime;//等待时间JCB[i].TAtime=JCB[i].finishTime-JCB[i].arrtime;//周转时间 JCB[i].TAWtimei=JCB[i].TAtime/JCB[i].runTime;//带权周转时间k+=JCB[i].TAtime;m+=JCB[i].TAWtimei;}AvgCycleTime=k/y;//平均旋转时间AvgValueCycleTime=m/y;//平均带权旋转时间printf("作业名提交时间开始时间运行时间结束时间等待时间周转时间带权周转时间\n");for(i=0;i<y;i++)printf("%s\t%.2f\t%.2f\t%4.2f\t%6.2f\t%7.2f\t%7.2f\t%8.2f\n\n",JCB[i] .name,JCB[i].arrtime,JCB[i].startTime,JCB[i].runTime,JCB[i].finishTim e,JCB[i].waitTime,JCB[i].TAtime,JCB[i].TAWtimei);printf("平均周转时间为：");printf("%.2f\n\n",AvgCycleTime);printf("平均带权周转时间为：");printf("%.2f\n\n",AvgValueCycleTime);}void FCFS(int y)//先来先服务算法{float p;int i,j;char h[100];for(i=0;i<y;i++){for(j=i+1;j<y;j++){if(JCB[i].arrtime>JCB[j].arrtime){displayone(p,h,i,j);}}}displaytow(i,y);}void SJF(int y)//短作业优先算法{float p;int i,j;char h[100];for(i=0;i<y;i++)//先提交的作业先运行，后面来的作业再比较运行时间长短{for(j=i+1;j<y;j++){if(JCB[i].arrtime>JCB[j].arrtime)//先把作业按提交时间来排序{displayone(p,h,i,j);}}}for(i=1;i<y;i++){for(j=i+1;j<y;j++){if(JCB[i].runTime>JCB[j].runTime)//比较后面来的作业的运行时间{displayone(p,h,i,j);}}}displaytow(i,y);}void HRRN(int y)//响应比高者优先算法{int i,j;float p;char h[100];for(i=0;i<y;i++)//先提交的作业先运行，后面来的作业再比较响应比的大小{for(j=i+1;j<y;j++){if(JCB[i].arrtime>JCB[j].arrtime)//先把作业按提交时间来排序{displayone(p,h,i,j);}}}for(i=0;i<y;i++){JCB[0].startTime=JCB[0].arrtime;JCB[i].finishTime=JCB[i].startTime+JCB[i].runTime;//结束时间JCB[i+1].startTime=JCB[i].finishTime;JCB[i].waitTime=JCB[i].startTime-JCB[i].arrtime;//等待时间JCB[i].TAtime=JCB[i].finishTime-JCB[i].arrtime;//周转时间 JCB[i].bi=JCB[i].TAtime/JCB[i].runTime;//响应比}for(i=1;i<y;i++){for(j=i+1;j<y;j++){if(JCB[i].bi<JCB[j].bi)//比较后面来的作业的响应比{displayone(p,h,i,j);p=JCB[i].bi;JCB[i].bi=JCB[j].bi;JCB[j].bi=p;}}}displaytow(i,y);for(i=1;i<y;i++){printf("%s的响应比为：%.2f\n",JCB[i].name,JCB[i].bi);}}int main(){while(1){int i,x,n;menu();loop1:printf("请选择模块(0~3): ");scanf("%d",&i);if(i==0){exit(0);}elseif(i<=0||i>3){printf("输入有误，请重新输入\n");goto loop1;//无条件转移语句}loop2:printf("原始数据是:\n");n=ReadFile();for(x=0;x<n;x++){printf("\n%s%15f%12f",JCB[i].name,JCB[i].arrtime,JCB[i].runTime);}switch(i){case 0:exit(0);break;case 1:FCFS(n);break;case 2:SJF(n);break;case 3:HRRN(n);break;}}}实验截图说明如下：这是先来先服务算法调度这是最短优先作业调度算法结果这是响应比高者优先调度算法结果2、编写并调度一个多道程序系统的作业调度模拟程序。

实验二作业调度一、实验名称作业调度算法的模拟实现二、实验目标作业调度又称宏观调度，其主要任务是对磁盘设备上大量的后备作业，以一定的原则进行挑选，给选中的作业分配内存等必须的资源，建立其相应的进程，让其投入运行。

本实验要求学生用高级程序设计语言编写和调试一个简化的作业调度程序，模拟实现的调度算法包括：先来先服务调度算法，短作业优先调度算法，响应比高者优先调度算法等，并对这些算法的性能做比较和评价。

以加深学生对作业、作业调度以及作业调度的各种算法的理解。

三、实验环境要求Windows+Visual C++ 6.0；四、实验基本原理作业调度主要是完成作业从后备状态到执行状态的转变，以及从执行状态到完成状态的转变。

（1）创建JCB（作业控制块）：系统在作业进入后备状态时为每个作业创建一个作业控制块（JCB）,从而使该作业可被调度程序感知。

当该作业执行完毕进入完成状态时候，系统自动撤销其JCB并释放有关资源，进而撤销该作业。

（2）按照作业调度算法，从后备队列中挑选一作业投入运行。

作业调度程序为运行作业建立相应的进程，并分配资源。

（3）主要的作业调度算法包括：先来先服务（FCFS）、短作业优先和最高响应比。

（4）调度策略的指标：最常用的调度性能指标有，周转时间（带权）、吞吐率、响应时间以及设备利用率。

五、数据结构设计（1）作业控制块，包括作业的基本信息描述。

struct time //时间的数据结构{int hour;int minute;};struct Job //作业{string jobname; //作业名time intime; //进入时间int runtime; //作业估计运行时间time starttime; //作业开始时间time endtime; //作业结束时间int cycletime; //作业周转时间float cltime; //作业带权周转时间bool haverun; //是否已运行};六、流程图图1 作业调度算法流程图七、源代码#include <iostream>#include <string>using namespace std;struct time //时间的数据结构{int hour;int minute;};struct Job //作业{string jobname; //作业名time intime; //进入时间int runtime; //作业估计运行时间time starttime; //作业开始时间time endtime; //作业结束时间int cycletime; //作业周转时间float cltime; //作业带权周转时间bool haverun; //是否已运行};float T=0;//作业平均周转时间float W=0;//作业带权平均周转时间void showInput(Job job[],int &n) //输入提示{cout<<"**********请按作业进入时间先后顺序输入*********"<<endl;for(int i=0;i<n;i++){cout<<"作业"<<i+1<<":"<<endl;cout<<"作业名:";cin>>job[i].jobname;cout<<"作业进入时间:";scanf("%d:%d",&job[i].intime.hour,&job[i].intime.minute);cout<<"作业估计运行时间:";cin>>job[i].runtime;job[i].starttime.hour=0;job[i].starttime.minute=0;job[i].endtime.hour=0;job[i].endtime.minute=0;job[i].cycletime=0;job[i].cltime=0;job[i].haverun=false; //标记为未运行cout<<"*********************"<<endl;}}void Init(Job job[],int &n)//初始化{for(int i=0;i<n;i++){job[i].starttime.hour=0;job[i].starttime.minute=0;job[i].endtime.hour=0;job[i].endtime.minute=0;job[i].cycletime=0;job[i].cltime=0;job[i].haverun=false; //标记为未运行}T=0;W=0;}void showTime(time time) //显示时间{cout<<time.hour<<":"<<time.minute;}int timeDiff(time t1,time t2) //计算时间差,时间t1比t2大{return t1.hour*60+t1.minute-(t2.hour*60+t2.minute);}time timeAdd(time time,int addtime) //时间相加{time.hour+=addtime/60;time.minute+=addtime%60;if(time.minute>=60){time.hour++;time.minute-=60;}return time;}bool comtime(time t1,time t2)//比较两个时间的大小，第一个大就返回TRUE {if(t1.hour>t2.hour)return true;else if(t1.hour==t2.hour&&t1.minute>=t2.minute)return true;elsereturn false;}void showResult(Job job[],int &n) //显示结果{cout<<"jobname\tintime\truntime\tsttime\tendtime\t周转时间(分钟)\t带权周转时间"<<endl;cout<<"*********************************************************** ********"<<endl;for(int i=0;i<n;i++){cout<<job[i].jobname<<"\t";showTime(job[i].intime);cout<<"\t"<<job[i].runtime<<"\t";showTime(job[i].starttime);cout<<"\t";showTime(job[i].endtime);cout<<"\t "<<job[i].cycletime<<"\t\t "<<job[i].cltime<<endl;}cout<<"作业平均周转时间：T="<<T/(n*1.0)<<endl;cout<<"作业带权平均周转时间：W="<<W/(n*1.0)<<endl;}int minRuntime(Job job[],int &n,time &t) //找出作业中最短作业下标{int min=-1;for(int i=0;i<n;i++){if(job[i].haverun==false && comtime(t,job[i].intime)==true){min=i;break;}}for(int j=min+1;j<n;j++)if(job[j].haverun==false && job[j].runtime<job[min].runtime && comtime(t,job[j].intime)==true)min=j;return min;}void SJF(Job job[],int &n)//短作业优先作业调度{struct time t;job[0].starttime.hour=job[0].intime.hour;job[0].starttime.minute=job[0].intime.minute;job[0].endtime=timeAdd(job[0].starttime,job[0].runtime);job[0].haverun=true;job[0].cycletime=timeDiff(job[0].endtime,job[0].intime);job[0].cltime=job[0].cycletime*1.0/job[0].runtime;T+=job[0].cycletime;W+=job[0].cltime;t=job[0].endtime;while(minRuntime(job,n,t)!=-1){int i=minRuntime(job,n,t);if(comtime(job[i].intime,t))job[i].starttime=job[i].intime;elsejob[i].starttime=t;job[i].endtime=timeAdd(job[i].starttime,job[i].runtime);job[i].haverun=true;job[i].cycletime=timeDiff(job[i].endtime,job[i].intime);job[i].cltime=job[i].cycletime*1.0/job[i].runtime;T+=job[i].cycletime;W+=job[i].cltime;t=job[i].endtime;}}int Firstintime(Job job[],int &n) //找出作业中最先到的{int min=-1;for(int i=0;i<n;i++){if(job[i].haverun==false){min=i;break;}}for(int j=min+1;j<n;j++)if(job[j].haverun==false && comtime(job[min].intime,job[j].intime)) min=j;return min;}void FCFS(Job job[],int &n)//先来先服务作业调度{struct time t;job[0].starttime.hour=job[0].intime.hour;job[0].starttime.minute=job[0].intime.minute;job[0].endtime=timeAdd(job[0].starttime,job[0].runtime);job[0].haverun=true;job[0].cycletime=timeDiff(job[0].endtime,job[0].intime);job[0].cltime=job[0].cycletime*1.0/job[0].runtime;T+=job[0].cycletime;W+=job[0].cltime;t=job[0].endtime;while(Firstintime(job,n)!=-1){int i=Firstintime(job,n);if(comtime(job[i].intime,t))job[i].starttime=job[i].intime;elsejob[i].starttime=t;job[i].endtime=timeAdd(job[i].starttime,job[i].runtime);job[i].haverun=true;job[i].cycletime=timeDiff(job[i].endtime,job[i].intime);job[i].cltime=job[i].cycletime*1.0/job[i].runtime;T+=job[i].cycletime;W+=job[i].cltime;t=job[i].endtime;}}void main(){cout<<"请输入作业数：";int n; //作业数cin>>n;Job *job=new Job[n];if(n<=0){cout<<"输入不合法!";exit(-1);}else{showInput(job,n);cout<<endl;FCFS(job,n);cout<<"先来先服务："<<endl;showResult(job,n);cout<<endl;Init(job,n);SJF(job,n); //短作业优先cout<<"短作业优先："<<endl;showResult(job,n);}system("pause");}八、运行结果用户输入作业的相关信息，程序输出相应的各种算法运行结果。

实验二作业调度一、实验内容模拟批处理作业调度。

二. 实验目的(1) 加深对作业概念的理解。

(2) 深入了解批处理系统如何组织作业、管理作业和调度作业。

(3) 掌握作业调度算法三. 实验设计3.1 数据结构设计作业调度实现的主要有两个问题，一个是如何将系统中的作业组织起来；另一个是如何进行作业调度。

为了将系统中的作业组织起来，需要为每个进入系统的作业建立作业控制块，其中包括作业相关的信息，例：作业名、作业所需资源、作业执行时间等。

拟采用链式存储，结构中还包括指向下一作业控制块的指针等。

Jcb结构定义的C＋＋描述如下：typedef struct{char name[6]; //作业名//int runtime; //运行时间int length; //所需主存空间int tapes; //所需磁带数//int arrivetime; //到达时间struct jcb *next; //指向下一个作业控制块} jcb，*jcblist;接收作业，需要为作业分配作业所需资源。

并且，在作业的进进出出过程中，系统的可用资源是动态变化的。

为此，需要记载系统的可用资源。

本设计题中牵涉到内存和磁带两种资源，以如下数据结构记载系统资源。

//可用资源数据结构struct Resource{int mem;int tapes;};struct Resource ar={1000,4};//ar->mem=500;//ar.tapes=4;struct Resource rr=ar; //剩余资源数3.2 求解方法作业调度从作业后备队列中的一批作业中挑选出若干个可运行的作业，并为这些被选中的作业分配所需的系统资源，当它们能够被进程调度选中时，就可占用处理器运行。

作业调度选择一个作业的必要条件是系统中现有的尚未分配的资源可满足该作业的资源要求。

但有时系统中现有的尚未分配的资源既可满足某个作业的要求也可满足其它一些作业的要求，那么，作业调度必须按一定的算法在这些作业中作出选择。

实验二作业调度实验题目1、编写并调试一个单道解决系统的作业等待模拟程序。

作业调度算法:分别采用先来先服务（FCFS）,最短作业优先（SJF）的调度算法。

（1 ）先来先服务算法:按照作业提交给系统的先后顺序来挑选作业，先提交的先被挑选。

（2）最短作业优先算法：是以进入系统的作业所提出的“执行时间”为标准,总是优先选取执行时间最短的作业。

二.实验目的：本实验规定用高级语言（C语言实验环境）编写和调试一个或多个作业调度的模拟程序，了解作业调度在操作系统中的作用，以加深对作业调度算法的理解三.实验过程〈一〉单道解决系统作业调度1）单道解决程序作业调度实验的源程序:zuoye.c 执行程序：zu o y e.exe2）实验分析：1、由于在单道批解决系统中，作业一投入运营，它就占有计算机的一切资源直到作业完毕为止，因此调度作业时不必考虑它所需要的资源是否得到满足，它所占用的CP U时限等因素。

2、每个作业由一个作业控制块JCB表达,JCB可以包含如下信息:作业名、提交时间、所需的运营时间、所需的资源、作业状态、链指针等等。

作业的状态可以是等待W（Wait）、运营R（Run）和完毕F（Finish）三种状态之一。

每个作业的最初状态else i f (p->n e e d time<min->need t ime) m in=p； p= p ->next；( while (p!=NULL);i f (iden) {i—；/ / pr i n tf ("\nt i m e =%d: \ t no JCB sub mib.. . wait . . . t ime);tim e s++；i f ( times> 10 0) {prin t f("\nru n t ime i s too Ion g . .. error z，) ;g etc h () ； ))e 1 s e{ru n ning(m i n, m) ；//调用running ()函数}} //forf i na 1 (); 〃调用r u nn i ng()函数)voi d fefs (int m)〃先来先服务算法(int i, iden;syst e m ("cl s ");i ni t a 1 ();f or(i=0;i<n;i++)(p= r ea d y； i d en=l;do{if (p-> s tate= = , W* & &p ->reach t i me<=t i mes) i d e n=0：i f (i d e n )p= p -> n ext;}while(p!=NULL&&iden);if (i d on){i——；prin tf(〃\ n没有满足规定的进程，需等待”)；t imes++;i f (time s >1 0 0 ) {prin t f ("\n 时间过长")；getch () ;})e 1 se{runn i ng(p, m); 〃调用r u nn i n g ()函数))final () ;//调用ru n n i n g ()函数}void muneO{int m;s y s tem (〃 c 1 s〃)；p r i n t f (z/\ n\n\t\t *** 火 * ****** * ***** * ***** *** *** * *** * **** ***** **\ t \ t\n ");P rintf ('\t \ t \ t\t 作业调度演示\ n ")；pr i ntf( " \t\t^ ***** * * *** * *** * ******** * * **** * ******** * * *** * \t\P r intf(*\n\n\n\t\ t \tl.先来先服务算法.;pr i nt f ("\n\t\ t \ t2.最短作业优先算法.;printfC\n\ t \ t \t3.响应比高者优先算法");prin t f ( ° \0.退出程序.;P rintfC \n\n\t \t\ t \t 选择所要操作:");s c anf (*%d*, &m);sw i tc h (m)(c ase 1:f c f s (m);getchO ；s y stem("c 1 s");mune();brea k ;c a se 2 :sjf (m):getch ();system ( " cis*)；mune ();break；case 3 :hr n (m);g e t c h ();sys t em("cls");mune ()；br e a k ；case 0:system ("cis");break;d e f a u 1 t :pr intf(〃选择错误，重新选择getchO ;system ("c Is");muneO ;))main ()//主函数(i niz e ();muneO ;)5)调试结果：i.选择操作的界面程课件'计算机操作系统联作系统实验八作业调度\zuoye.exe ，作业调度演示.先来先服务算法.1 .最短企业优先算法.2 .响应居意者优先萱法 4战出程序.选择所要操作:2.输入操作初始信息:c 「E:\课程课件'计算机》3 .先来先服务算法作业调度结果：（调度顺序：a -> b ->c->d->e ）输入作业数：5输入作业数：5太人作业名:a7、侬、|到达时间:0要运行的时间：4 必法崎松时间其要运行的时间：3植入作业名:c 作业默认到达时间:2 曲人作批要运行的时间;5 植入作业名:d 伟业默认到达时间：3 曲入作要运行的时间;2 检入作业名:e 伟业默认到达时间;4 输入作业要运行的时间;4作业证在运行，估计其运行情况: 开始运宜时刻：。

操作系统实验报告作业调度操作系统实验报告：作业调度引言：操作系统是计算机系统中最核心的软件之一，它负责管理计算机的资源，为用户提供良好的使用环境。

在操作系统中，作业调度是非常重要的一部分，它决定了计算机如何合理地分配和调度各个作业的执行顺序，以提高计算机的效率和性能。

本实验报告将介绍作业调度的概念、调度算法以及实验结果。

一、作业调度的概念作业调度是指根据一定的策略和算法，将就绪队列中的作业按照一定的顺序分配给处理器，使得计算机系统能够充分利用资源，提高系统的吞吐量和响应时间。

作业调度的目标是实现公平性、高效性和平衡性。

二、作业调度的算法1. 先来先服务（FCFS）调度算法FCFS调度算法是最简单的调度算法之一，它按照作业的到达顺序进行调度，先到达的作业先执行。

这种算法的优点是简单易实现，但是可能会导致长作业等待时间过长，造成资源浪费。

2. 最短作业优先（SJF）调度算法SJF调度算法是根据作业的执行时间来进行调度，执行时间短的作业先执行。

这种算法能够最大程度地减少平均等待时间，提高系统的响应速度，但是可能会导致长作业长时间等待。

3. 优先级调度算法优先级调度算法是根据作业的优先级来进行调度，优先级高的作业先执行。

这种算法可以根据不同的需求设置不同的优先级，但是可能会导致低优先级的作业长时间等待。

4. 时间片轮转调度算法时间片轮转调度算法是将处理器的执行时间划分为多个时间片，每个作业在一个时间片内执行，时间片用完后，将处理器分配给下一个作业。

这种算法可以实现公平性，但是可能会导致长作业等待时间过长。

三、实验结果与分析在本次实验中，我们使用了不同的作业调度算法，并对其进行了性能测试。

测试结果显示，FCFS算法在平均等待时间方面表现较差，而SJF算法和优先级调度算法在平均等待时间方面表现较好。

时间片轮转调度算法能够实现公平性，但是可能会导致长作业等待时间过长。

结论：作业调度是操作系统中的重要组成部分，合理的作业调度算法能够提高计算机系统的效率和性能。

实验二作业调度实验一 . 目的要求：用高级语言编写和调试作业调度的模拟程序，以加深对作业调度算法的理解。

二、实验要求：为单道批处理系统设计一个作业调度程序。

由于在单道批处理系统中，作业一投入运行，它就占有计算机的一切资源直到作业完成为止，因此调度作业时不必考虑它所需要的资源是否得到满足、它所占用的 CPU时限等因素。

作业调度算法：分别采用先来先服务、短作业优先、高响应比调度算法。

每个作业由一个作业控制块JCB表示，JCB可以包含如下信息：作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。

作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。

每个作业的最初状态总是等待W。

每个作业完成后要打印该作业的开始运行时刻、完成时刻、周转时间和带权周转时间，这一组作业完成后要计算并打印这组作业的平均周转时间、带权平均周转时间。

源代码：#include <stdio.h>#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type))#define NULL 0int n;float T1=0,T2=0;int times=0;struct jcb //作业控制块{char name[10]; //作业名int reachtime; //作业到达时间int starttime; //作业开始时间int needtime; //作业需要运行的时间float super; //作业的响应比int finishtime; //作业完成时间float cycletime; //作业周转时间float cltime; //作业带权周转时间char state; //作业状态struct jcb *next; //结构体指针}*ready=NULL,*p,*q;typedef struct jcb JCB;void inize() //初始化界面{printf("\n\n\t\t*********************************************\t\t\n"); printf("\t\t\t\t单道批处理作业调度系统\n");printf("\t\t*********************************************\t\t\n"); printf("\n\n\n\t\t\t\t\t09软件+电子商务2班\n");printf("\t\t\t\t\t\t黄才旺\n\n");printf("\n\n\n\t\t请按任意键进入主菜单：");getch();}void inital() //建立作业控制块队列,先将其排成先来先服务的模式队列{int i;printf("\n输入作业数:");scanf("%d",&n);for(i=0;i<n;i++){p=getpch(JCB);printf("\n输入作业名:");scanf("%s",p->name);getch();p->reachtime=i;printf("作业默认到达时间:%d",i);printf("\n输入作业需运行时间:");scanf("%d",&p->needtime);p->state='W';p->next=NULL;if(ready==NULL) ready=q=p;else{q->next=p;q=p;}}}void disp(JCB* q,int m) //显示作业运行后的周转时间及带权周转时间等{if(m==3) //显示高响应比算法调度作业后的运行情况{printf("\n作业%s正在运行，估计其运行情况：\n",q->name);printf("\n 开始运行时刻 \t 完成时刻 \t 周转时间 \t 带权周转时间 \t相应比 \n");printf(" %d \t",q->starttime);printf(" %d \t",q->finishtime);printf(" %f \t",q->cycletime);printf(" %f\t",q->cltime);printf(" %f\n",q->super);getch();}else // 显示先来先服务,最短作业优先算法调度后作业的运行情况{printf("\n作业%s正在运行，估计其运行情况：\n",q->name);printf("\n 开始运行时刻 \t 完成时刻 \t 周转时间 \t 带权周转时间 \n");printf(" %d \t",q->starttime);printf(" %d \t",q->finishtime);printf(" %f \t",q->cycletime);printf(" %f\t",q->cltime);getch();}}void running(JCB *p,int m) //运行作业{if(p==ready) //先将要运行的作业从队列中分离出来 {ready=p->next;p->next=NULL;}else{q=ready;while(q->next!=p) q=q->next;q->next=p->next;}p->starttime=times;//计算作业运行后的完成时间,周转时间等等 p->state='R';p->finishtime=p->starttime+p->needtime;p->cycletime=(float)(p->finishtime-p->reachtime);p->cltime=(float)(p->cycletime/p->needtime);T1+=p->cycletime;T2+=p->cltime;disp(p,m); //调用disp()函数,显示作业运行情况 times+=p->needtime;p->state='F';printf("\n%s 作业已完成!\n请按任意键继续...\n",p->name);free(p); //释放运行后的作业getch();}void super() //计算队列中作业的高响应比{JCB *padv;padv=ready;do{if(padv->state=='W'&&padv->reachtime<=times)padv->super=(float)(times-padv->reachtime+padv->needtime)/padv->n eedtime;padv=padv->next;}while(padv!=NULL);}void final() //最后打印作业的平均周转时间,平均带权周转时间{float s,t;t=T1/n;s=T2/n;getch();printf("\n\n作业已经全部完成!");printf("\n%d个作业的平均周转时间是：%f",n,t);printf("\n%d个作业的平均带权周转时间是：%f\n\n\n",n,s);}void hrn(int m) //高响应比算法{JCB *min;int i,iden;system("cls");inital();for(i=0;i<n;i++){p=min=ready;iden=1;super();do{if(p->state=='W'&&p->reachtime<=times)if(iden){min=p;iden=0;}else if(p->super>min->super) min=p;p=p->next;}while(p!=NULL);if(iden){i--;times++;if(times>1000){printf("\nruntime is too long...error...");getch();}}else{running(min,m); //调用running()函数}} //forfinal(); //调用running()函数}void sjf(int m) // 最短作业优先算法{JCB *min;int i,iden;system("cls");inital();for(i=0;i<n;i++){p=min=ready;iden=1;do{if(p->state=='W'&&p->reachtime<=times)if(iden){min=p;iden=0;}else if(p->needtime<min->needtime) min=p;p=p->next;}while(p!=NULL) ;if(iden) {i--;times++;if(times>100){printf("\nruntime is too long...error");getch();} }else{running(min,m); //调用running()函数}} //forfinal(); //调用running()函数}void fcfs(int m) //先来先服务算法{int i,iden;system("cls");inital();for(i=0;i<n;i++){p=ready;iden=1;do{if(p->state=='W'&&p->reachtime<=times) iden=0;if(iden)p=p->next;}while(p!=NULL&&iden) ;if(iden){i--;printf("\n没有满足要求的进程,需等待");times++;if(times>100){printf("\n时间过长");getch();}}else{running(p,m); //调用running()函数}}final(); //调用running()函数}void mune(){int m;system("cls");printf("\n\n\t\t*********************************************\t\t\n"); printf("\t\t\t\t作业调度主菜单\n");printf("\t\t*********************************************\t\t\n");printf("\n\n\n\t\t\t1.先来先服务算法");printf("\n\t\t\t2.最短作业优先算法");printf("\n\t\t\t3.响应比高者优先算法");printf("\n\t\t\t0.退出程序");printf("\n\n\t\t\t\t选择算法:");scanf("%d",&m);switch(m){case 1:fcfs(m);getch();system("cls");mune();break;case 2:sjf(m);getch();system("cls");mune();break;case 3:hrn(m);getch();system("cls");mune();break;case 0:system("cls");break;default:printf("选择错误,重新选择."); getch();system("cls");mune();}}main() //主函数{inize();mune();}选择1进入“先来先服务算法”作业调度：选择2进入“最短作业优先算法”作业调度：选择3进入“响应比高者优先算法”作业调度：。

操作系统实验二作业调度实验一、目的要求用高级语言编写和调试一个或多个作业调度的模拟程序，以加深对作业调度算法的理解。

1. 编写并调试一个单道处理系统的作业等待模拟程序。

作业等待算法：分别采用先来先服务（FCFS），最短作业优先（SJF）、响应比高者优先（HRN）的调度算法。

对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间，以及这组作业的平均周转时间及带权平均周转时间，以比较各种算法的优缺点。

#include "stdio.h"#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type))//#define NULL 0struct worktime{float Tb; //作业运行时刻float Tc; //作业完成时刻float Ti; //周转时间float Wi; //带权周转时间};struct jcb { /*定义作业控制块JCB */char name[10]; //作业名float subtime; //作业提交时间float runtime; //作业所需的运行时间char resource; //所需资源float Rp; //后备作业响应比char state; //作业状态struct worktime wt;struct jcb* link; //链指针}*jcb_ready=NULL,*j;typedef struct jcb JCB;float T=0;void sort() /* 建立对作业进行提交时间排列函数*/{JCB *first, *second;int insert=0;if((jcb_ready==NULL)||((j->subtime)<(jcb_ready->subtime))) /*作业提交时间最短的,插入队首*/{j->link=jcb_ready;jcb_ready=j;T=j->subtime;j->Rp=1;}else /* 作业比较提交时间,插入适当的位置中*/{first=jcb_ready;second=first->link;while(second!=NULL){if((j->subtime)<(second->subtime)) /*若插入作业比当前作业提交时间短,*/{ /*插入到当前作业前面*/j->link=second;first->link=j;second=NULL;insert=1;}else /* 插入作业优先数最低,则插入到队尾*/{first=first->link;second=second->link;}}if (insert==0) first->link=j;}}void SJFget()/* 获取队列中的最短作业*/{JCB *front,*mintime,*rear;int ipmove=0;mintime=jcb_ready;rear=mintime->link;while(rear!=NULL){if((rear!=NULL)&&(T>=rear->subtime)&&(mintime->runtime)>(rear->runtime)) {front=mintime;mintime=rear;rear=rear->link;ipmove=1;}elserear=rear->link;}if (ipmove==1){front->link=mintime->link;mintime->link=jcb_ready;}jcb_ready=mintime;}void HRNget()/* 获取队列中的最高响应作业*/{JCB *front,*mintime,*rear;int ipmove=0;mintime=jcb_ready;rear=mintime->link;while(rear!=NULL){if ((rear!=NULL)&&(T>=rear->subtime)&&(mintime->Rp)<(rear->Rp)){front=mintime;mintime=rear;rear=rear->link;ipmove=1;}elserear=rear->link;}if (ipmove==1){front->link=mintime->link;mintime->link=jcb_ready;}jcb_ready=mintime;}void input() /* 建立作业控制块函数*/{int i,num;printf("\n 请输入作业数:?");scanf("%d",&num);for(i=0;i<num;i++){printf("\n 作业号No.%d:\n",i);j=getpch(JCB);printf("\n 输入作业名:");scanf("%s",j->name);printf("\n 输入作业提交时刻:");scanf("%f",&j->subtime);printf("\n 输入作业运行时间:");scanf("%f",&j->runtime);printf("\n");j->state='w';j->link=NULL;sort(); /* 调用sort函数*/}}int space(){int l=0; JCB* jr=jcb_ready;while(jr!=NULL){l++;jr=jr->link;}return(l);}void disp(JCB* jr,int select) /*建立作业显示函数,用于显示当前作业*/{if (select==3) printf("\n 作业服务时间响应比运行时刻完成时刻周转时间带权周转时间\n");else printf("\n 作业服务时间运行时刻完成时刻周转时间带权周转时间\n");printf(" |%s\t",jr->name);printf(" |%.2f\t ",jr->runtime);if (select==3) printf(" |%.2f ",jr->Rp);if (j==jr){printf(" |%.2f\t",jr->wt.Tb);printf(" |%.2f ",jr->wt.Tc);printf(" |%.2f \t",jr->wt.Ti);printf(" |%.2f",jr->wt.Wi);}printf("\n");}void destroy() /*建立作业撤消函数(作业运行结束,撤消作业)*/{printf("\n 作业[%s] 已完成.\n",j->name);free(j);}void check(int select) /* 建立作业查看函数*/{JCB* jr;printf("\n **** 当前正在运行的作业是:%s",j->name); /*显示当前运行作业*/ disp(j,select);jr=jcb_ready;printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/while(jr!=NULL){jr->Rp=(T-jr->subtime)/jr->runtime;disp(jr,select);jr=jr->link;}destroy();}void running(JCB* jr) /* 建立作业就绪函数(作业运行时间到,置就绪状态*/ {if (T>=jr->subtime) jr->wt.Tb=T; else jr->wt.Tb=jr->subtime;jr->wt.Tc=jr->wt.Tb+jr->runtime;jr->wt.Ti=jr->wt.Tc-jr->subtime;jr->wt.Wi=jr->wt.Ti/jr->runtime;T=jr->wt.Tc;}int main() /*主函数*/{int select=0,len,h=0;float sumTi=0,sumWi=0;input();len=space();printf("\n\t1.FCFS 2.SJF 3.HRN\n\n请选择作业调度算法:?");scanf("%d",&select);while((len!=0)&&(jcb_ready!=NULL)){h++;printf("\n 执行第%d个作业\n",h);j=jcb_ready;jcb_ready=j->link;j->link=NULL;j->state='R';running(j);sumTi+=j->wt.Ti;sumWi+=j->wt.Wi;check(select);if (select==2&&h<len-1) SJFget();if (select==3&&h<len-1) HRNget();printf("\n 按任一键继续......\n");getchar();getchar();}printf("\n\n 作业已经完成.\n");printf("\t 此组作业的平均周转时间：%.2f\n",sumTi/h);printf("\t 此组作业的带权平均周转时间：%.2f\n",sumWi/h);getchar();}。

操作系统实验五：作业调度算法时间：2013-12-27地点：计算机实验机房2实验人：朱蓉蓉学号：E01114336本次实验主要是进行先来先服务调度算法、短作业优先调度算法、高优先权优先调度算法的编程。

实验代码如下：#include <iostream.h>#include <stdio.h>#include <string.h>void FCFS(); //先来先服务void SJF(); //短作业优先void FPF(); //高优先权void input(); //输入函数void operation(); //运算输出函数int n; //全局变量作业输入量double avturn; //平均周转时间double avdqzz; //平均带权周转时间double t=0.0,k=0.0; //全局变量用来表示总的周转时间和总的带权周转时间struct HomeWork{int num; //作业号char name; //进程名double arrivetime; //到达时间double servetime; //服务时间double begintime; //开始时间double endtime; //完成时间double turntime; //周转时间double dqzztime; //带权周转时间double zgxy; //最高响应比}HW[10];void input(){cout<<"请输入要执行作业的数量："<<endl;cin>>n;for(int i=1;i<=n;i++){cout<<"请输入第"<<i<<"个作业的数据："<<endl;HW[i].num=i;cout<<"进程名：";cin>>HW[i].name;cout<<"到达时间：";cin>>HW[i].arrivetime;cout<<"服务时间：";cin>>HW[i].servetime;}}void operation(){for(int i=1;i<=n;i++){if(i==1)HW[i].begintime=HW[i].arrivetime; //如果是第一个作业开始时间就是到达时间elseHW[i].begintime=HW[i-1].endtime;//如果不是，则作业的开始时间是前一个的结束时间HW[i].endtime=HW[i].begintime+HW[i].servetime;HW[i].turntime=HW[i].endtime-HW[i].arrivetime;HW[i].dqzztime=HW[i].turntime/HW[i].servetime;}for(i=1;i<=n;i++){t=t+HW[i].turntime;k=k+HW[i].dqzztime;}avturn=t/n;avdqzz=k/n;cout<<"作业序号进程名到达时间服务时间开始时间完成时间周转时间带权周转时间 "<<endl;for(i=1;i<=n;i++)cout<<" "<<HW[i].num<<" "<<HW[i].name<<" \t"<<HW[i].arrivetime<<" \t"<<HW[i].servetime<<" \t"<<HW[i].begintime<<" \t"<<HW[i].endtime<<" \t"<<HW[i].turntime<<" \t"<<HW[i].dqzztime<<endl;cout<<"平均周转时间："<<avturn<<endl;cout<<"平均带权周转时间："<<avdqzz<<endl;}void FCFS(){cout<<"\n*********************先来先服务（FCFS）算法*********************\n";operation();t=0.0;k=0.0;}void SJF(){cout<<"\n*********************短作业优先（SJF）算法*********************\n";int no; //作业号double tjtime; //提交时间double zxtime; //执行时间for(int i=2;i<=n;i++)for(int j=i+1;j<=n;j++){if(HW[i].servetime>HW[j].servetime){no=HW[i].num;HW[i].num=HW[j].num;HW[j].num=no; //作业号互换tjtime=HW[i].arrivetime;HW[i].arrivetime=HW[j].arrivetime;HW[j].arrivetime=tjtime; //作业到达时间互换zxtime=HW[i].servetime;HW[i].servetime=HW[j].servetime;HW[j].servetime=zxtime; //作业服务时间互换}}operation();t=0.0;k=0.0;}void FPF(){cout<<"\n*********************高优先权优先调度算法*********************\n";double tjtime,zxtime;int no;for(int i=2;i<=n;i++){if(HW[i].arrivetime<HW[i-1].endtime)//判断第二个作业是否是在第一个作业完成前提交的HW[i].zgxy=(HW[i-1].endtime-HW[i].arrivetime)/HW[i].servetime +1;for(int j=i+1;j<=n;j++){if(HW[j].arrivetime<HW[i].endtime)//判断后面作业是否是前一个作业完成前提交的HW[j].zgxy=(HW[j].begintime-HW[j].arrivetime)/HW[j].servetime +1;if(HW[i].zgxy<HW[j].zgxy){no=HW[i].num;HW[i].num=HW[j].num;HW[j].num=no; //作业号互换tjtime=HW[i].arrivetime;HW[i].arrivetime=HW[j].arrivetime;HW[j].arrivetime=tjtime; //作业提交时间互换zxtime=HW[i].servetime;HW[i].arrivetime=HW[j].arrivetime;HW[j].arrivetime=zxtime; //作业执行时间互换}}}operation();t=0.0;k=0.0;}void main(){input();FCFS();SJF();FPF();}实验结果截图：第一组数据：第二组数据：。

操作系统实验报告：作业调度1. 引言作业调度是操作系统中的一个重要概念，它涉及到如何合理地安排计算机系统中的作业执行顺序，以最大程度地提高系统的效率和性能。

本文将介绍作业调度的基本概念和主要算法，以及在实验中的应用。

2. 作业调度的概念作业调度是指根据一定的策略和算法，按照一定的顺序从作业队列中选取作业，将其分配给可用资源来执行的过程。

作业调度的目标是实现公平、高效的任务分配，以提高系统的整体性能。

3. 作业调度算法3.1 先来先服务（FCFS）先来先服务是最简单的作业调度算法，即按照作业提交的顺序来执行。

当一份作业到达系统后，它将被放入作业队列的末尾。

一旦当前执行的作业完成，系统将选择队列中的下一个作业来执行。

3.2 短作业优先（SJF）短作业优先算法是根据作业的执行时间来进行调度，执行时间越短的作业优先级越高。

当一个作业进入系统时，系统会检查队列中的所有作业，并选择执行时间最短的作业来执行。

3.3 优先级调度优先级调度算法是根据作业的优先级来进行调度，优先级越高的作业优先级越高。

每个作业都会被分配一个优先级值，系统会按照优先级从高到低的顺序来执行作业。

3.4 时间片轮转调度时间片轮转调度算法将作业分为多个时间片，每个时间片的执行时间相等。

当一个作业进入系统时，系统会分配给它一个时间片，如果在时间片内作业没有完成，则将其放回队列的末尾，并执行下一个作业。

4. 实验中的应用在操作系统实验中，作业调度是一个重要的实验内容。

通过实验，我们可以深入了解不同调度算法的特点和适用场景。

实验中，我们可以使用模拟器来模拟作业调度的过程。

我们可以创建一个作业队列，然后使用不同的调度算法来执行这些作业，并记录它们的执行时间和系统的吞吐量。

通过实验，我们可以比较不同算法在不同场景下的表现，选择最适合当前系统的作业调度算法。

5. 结论作业调度是一个重要的操作系统概念，它决定了系统的性能和效率。

在本文中，我们介绍了作业调度的基本概念和常用算法，并讨论了在实验中的应用。

一、实验目的1. 理解作业调度系统的基本原理和流程。

2. 掌握作业调度算法的设计与实现。

3. 评估不同作业调度算法的性能。

二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.73. 开发工具：PyCharm三、实验内容1. 作业调度系统概述2. 作业调度算法设计3. 作业调度系统实现4. 性能评估与分析四、实验步骤1. 作业调度系统概述（1）作业调度系统定义：作业调度系统是计算机系统中负责将作业分配到各个处理器（CPU）进行执行的部分。

（2）作业调度系统功能：作业调度系统负责接收作业、分析作业、选择作业执行、监控作业执行、处理作业异常等。

2. 作业调度算法设计（1）先来先服务（FCFS）算法：按照作业提交的顺序进行调度。

（2）短作业优先（SJF）算法：优先调度预计运行时间最短的作业。

（3）最高响应比优先（HRRN）算法：综合考虑作业的等待时间和估计运行时间，优先调度响应比最高的作业。

（4）轮转调度（RR）算法：将作业分配到各个处理器进行执行，每个处理器分配固定的时间片，时间片结束后进行抢占调度。

3. 作业调度系统实现（1）创建作业类：定义作业的属性，如作业ID、预计运行时间、实际运行时间等。

（2）创建调度器类：实现作业调度算法，包括作业接收、分析、选择、监控和异常处理等功能。

（3）创建处理器类：模拟CPU执行作业，记录作业执行时间。

（4）创建模拟环境：模拟多个作业提交到系统中，调度器根据算法进行调度，处理器执行作业。

4. 性能评估与分析（1）性能指标：平均等待时间、平均周转时间、吞吐量等。

（2）评估方法：通过模拟不同作业调度算法在相同作业集合下的性能，对比分析其优缺点。

（3）结果分析：根据实验结果，分析不同作业调度算法在处理不同作业集合时的性能表现。

五、实验结果与分析1. FCFS算法（1）平均等待时间：20ms（2）平均周转时间：25ms（3）吞吐量：0.82. SJF算法（1）平均等待时间：15ms（2）平均周转时间：20ms（3）吞吐量：0.93. HRRN算法（1）平均等待时间：18ms（2）平均周转时间：23ms（3）吞吐量：0.854. RR算法（1）平均等待时间：17ms（2）平均周转时间：22ms（3）吞吐量：0.86根据实验结果，SJF算法在处理短作业集合时具有较好的性能，平均等待时间和周转时间较短；而FCFS算法在处理长作业集合时性能较好，平均等待时间和周转时间较长。

实验二调度算法的模拟实现一、实验目的1.加深对先来先服务算法，短作业优先算法，最高优先权优先调度算法等三种调度算法的理解2.利用C语言编写算法，模拟实现先来先服务算法，短作业优先算法，最高优先权优先调度算法。

3.模拟三种调度算法，对比三种调度算法的优缺点，并计算平均周转时间和平均带权周转时间。

二、实验开发平台Microsoft Visual C++ 6.0（使用C语言）三、三个调度算法说明先来先服务调度算法，是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度，就是每次从就绪队列中选择一个最先进入队列的进程，该算法比较有利于长作业，而不利于短作业。

另处，FCFS调度算法对CPU繁忙型作业较有利，而不利于I/O繁忙作业。

短作业优先调度算法（SWF），是指对短作业或短进程优先调度的算法，是指分派CPU时，把CPU优先分给最短的作业。

它的缺点是对长作业不利，不能保证及时处理解紧迫性的作业。

最高优先权优先调度算法，常用于批处理系统中，既照顾了短作业，又考虑了作业到达的先后次序，不会使长作业长期得不到服务。

它实现了一种较好的折衷,但每要进行高度之前，都须先做响应比的计算，这会增加系统开销。

四、实验源程序#include <stdio.h>struct process{char name[10];int dtime;int ftime;int youxian;};struct process pro[3];struct process tempPro[3];void fcfs()//先来先服务{//先对这些线程排序,使用冒泡法排序，从小到大int i,j;for (i=0;i<3-1;i++){for (j=0;j<2-i;j++){if (pro[j].dtime>pro[j+1].dtime){tempPro[j]=pro[j];pro[j]=pro[j+1];pro[j+1]=tempPro[j];}}}}void sjf()//短作业优先{//使用冒泡法排序,从小到大int i,j;for (i=0;i<3-1;i++){for (j=0;j<2-i;j++){if (pro[j].ftime>pro[j+1].ftime){tempPro[j]=pro[j];pro[j]=pro[j+1];pro[j+1]=tempPro[j];}}}}void youxian()//最高优先权优先，假定此处为优先数最大的进程优先服务{ //使用冒泡法排序，从大到小int i,j;for (i=0;i<3-1;i++){for (j=0;j<2-i;j++){if (pro[j].youxian<pro[j+1].youxian){tempPro[j]=pro[j];pro[j]=pro[j+1];pro[j+1]=tempPro[j];}}}}void print()//输出进程名称{int i;for (i=0;i<3;i++){printf("%s\n",pro[i].name);}}void main(){printf("请输入第一个进程的名字到达时间服务时间优先数\n");scanf("%s %3d %3d %3d",&pro[0].name,&pro[0].dtime,&pro[0].ftime,&pro[0].youxian);printf("请输入第二个进程的名字到达时间服务时间优先数\n");scanf("%s %3d %3d %3d",&pro[1].name,&pro[1].dtime,&pro[1].ftime,&pro[1].youxian);printf("请输入第三个进程的名字到达时间服务时间优先数\n");scanf("%s %3d %3d %3d",&pro[2].name,&pro[2].dtime,&pro[2].ftime,&pro[2].youxian);printf("先来先服务调度执行顺序：\n");fcfs();print();printf("短作业优先调度执行顺序：\n");sjf();print();printf("最高优先权优先调度执行顺序：\n");youxian();print();}五、运行结果。

操作系统实验指导执笔：胡荣教研室：信息与计算科学教研室（实验参考网址：/p-5733545.html）实验一：进程调度一、目的要求用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解．二、实验要求1.编写并调试一个模拟的进程调度程序，采用“最高优先数优先”调度算法中的静态优先数调度对五个进程进行调度。

“最高优先数优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。

每个进程有一个进程控制块（ PCB）表示。

进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。

进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。

进程的到达时间为进程输入的时间。

静态优先数是在创建进程时确定的，并在整个进程运行期间不再改变。

动态优先数是指进程的优先数在创建进程时可以给定一个初始值，并且可以按一定原则修改优先数。

例如：在进程获得一次CPU后就将其优先数减少1。

或者，进程等待的时间超过某一时限时增加其优先数的值，等等。

动态优先数调度算法流程图如下：进程调度源程序如下：jingchendiaodu.cpp#include "stdio.h"#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type)) #define NULL 0struct pcb { /* 定义进程控制块PCB */char name[10];char state;int super;int ntime;int rtime;struct pcb* link;}*ready=NULL,*p;typedef struct pcb PCB;sort() /* 建立对进程进行优先级排列函数*/{PCB *first, *second;int insert=0;if((ready==NULL)||((p->super)>(ready->super))) /*优先级最大者,插入队首*/{p->link=ready;ready=p;}else /* 进程比较优先级,插入适当的位置中*/{first=ready;second=first->link;while(second!=NULL){if((p->super)>(second->super)) /*若插入进程比当前进程优先数大,*/ { /*插入到当前进程前面*/p->link=second;first->link=p;second=NULL;insert=1;}else /* 插入进程优先数最低,则插入到队尾*/{first=first->link;second=second->link;}}if(insert==0) first->link=p;}}input() /* 建立进程控制块函数*/{int i,num;clrscr(); /*清屏*/printf("\n 请输入进程号?");scanf("%d",&num);for(i=0;i<num;i++){printf("\n 进程号No.%d:\n",i); p=getpch(PCB);printf("\n 输入进程名:");scanf("%s",p->name);printf("\n 输入进程优先数:"); scanf("%d",&p->super);printf("\n 输入进程运行时间:"); scanf("%d",&p->ntime);printf("\n");p->rtime=0;p->state='w';p->link=NULL;sort(); /* 调用sort函数*/}}int space(){int l=0; PCB* pr=ready;while(pr!=NULL){l++;pr=pr->link;}return(l);}disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/{printf("\n qname \t state \t super \t ndtime \t runtime \n"); printf("|%s\t",pr->name);printf("|%c\t",pr->state);printf("|%d\t",pr->super);printf("|%d\t",pr->ntime);printf("|%d\t",pr->rtime);printf("\n");}check() /* 建立进程查看函数 */{PCB* pr;printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/disp(p);pr=ready;printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/while(pr!=NULL){disp(pr);pr=pr->link;}}destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/{printf("\n 进程 [%s] 已完成.\n",p->name);free(p);}running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/(p->rtime)++;if(p->rtime==p->ntime)destroy(); /* 调用destroy函数*/else{(p->super)--;p->state='w';sort(); /*调用sort函数*/}}main() /*主函数*/{int len,h=0;char ch;input();len=space();while((len!=0)&&(ready!=NULL)){ch=getchar();h++;printf("\n The execute number:%d \n",h);p=ready;ready=p->link;p->link=NULL;p->state='R';check();running();printf("\n 按任一键继续......");ch=getchar();}printf("\n\n 进程已经完成.\n");ch=getchar();}实验二：作业调度一. 目的要求：用高级语言编写和调试一个或多个作业调度的模拟程序，以加深对作业调度算法的理解。

华中师范大学计算机科学系实验报告书实验题目：作业调度算法课程名称：操作系统主讲教师：叶俊民教授辅导教师：课程编号：84810117 (1)班级：0903班实验时间：2011.10.26一、实验目的：1、掌握作业调度的基本思想2、熟练使用各种作业调度算法描述的过程3、掌握各种算法的优缺点4、提高理论和实践结合的能力二、实验内容：1、先来先服务算法2、最短作业优先算法3、最高响应比优先算法三、实验环境：实践平台：linux编写环境：codeblocks编译器： g++四、实验设计原理1、先来先服务算法根据作业输入输入井的先后顺序调度作业即先到达输入井的作业先被调度，后到达的作业后调度2、最短作业算法根据作业需要运行的时间的长短来确定调用哪一个作业，即当前输入井中需要执行时间越短越早执行3、最高响应比优先算法输入井中的每一个作业根据当前运行的作业计算出作业的响应比，响应比最高的将被调度五、实验详细实现过程与算法流程1、先来先服务第一个进入输入井的作业先执行，那么该作业就有一个执行结束的时间，那么在该作业运行时间内，满足时间条件的作业进入输入井，然后根据前一个作业的运行结束的时间推算和下一个作业要进入输入井的时间推算下一个作业时间开始运行的时间：Time = max（curendtime，nextstarttime）;这样后作业运行的开始时间就计算出来了，那么加上一个运行长度就是该作业的结束时间，周转时间即为结束时间减去进入输入井的时间2、最短作业优先算法这里设置一个优先队列，第一个作业先进入队列，第一个作业出队列，根据出队的作业的结束时间扫描能够满足条件的作业进入队列，重复如此操作直到作业调度完毕，在这个过程中，出队的作业，就能根据前一个作业的信息推算出当前作业的信息3、最高响应比优先算法这里采用了蛮力法：根据当前运行的作业的信息，再枚举输入井中等待运行的作业，算出等待运行作业的响应比，选择最大的执行，这样直到作业运行完毕六、实验调试与结果分析（问题的发现、分析、解决方案与创新）1、代码的界面开始让人看上去很烦，为了养成一个良好的编程习惯，就必须耐心的调试代码的风格和界面风格，要知道程序不是给你一个人看的，界面也不是给自己看的，得让他人看得明白和透彻2、采用了优先队列，效率比较高，且代码量小，编程容易，容易阅读3、程序中有很多小的错误，细节决定成败七、源程序（加注释）//作业调度程序#include<iostream>#include<cstdio>#include<cstring>#include<queue>#include<cstdlib>using namespace std;const int N=10000;struct node{char name[30];//作业的名字int Ctime; //作业进入输入井的时间（以分计）int Rtime; //作业的运行时间<以分计算>int Stime; //作业开始运行的时间int Etime; //作业运行结束的时间int Ttime; //作业周转时间float circle; //作业的周转周期}work[N];struct cmp{bool operator()(int i,int j){return work[i].Rtime>work[j].Rtime;}};int max (int a,int b){return a>b? a: b;}void FCFS();void SJF();void HRN();int main(){int op;while(1){printf("*****************************\n\n");printf(" 欢迎体验作业调度算法\n\n");printf(" 1.先来先服务\n\n");printf(" 2.最短作业优先法\n\n");printf(" 3.最高响应比算法\n\n");printf(" 0.退出\n\n");printf(" 请输入你的选择： ");scanf("%d",&op);switch(op){case 0: exit(0);case 1: FCFS();break; //跳转到先来先服务算法case 2: SJF();break; //跳转到最短优先服务算法case 3: HRN();break; // 跳转到最高响应比算法default :printf("\n 选择无效\n\n");}}return 0;}void FCFS(){int n,i,h,m;printf("******************************\n\n");printf(" 欢迎体验先来先服务算法 \n\n");printf(" 请输入作业的个数： ");scanf("%d",&n);printf("\n\n");printf(" 首先请按作业进入输入井时间的先后输入\n\n");printf(" 每个任务的格式为：\n\n 作业名称作业进入输入井的时间作业运行时间\n\n");printf(" ps: 进入输入井的时间格式为 h:m\n\n");printf(" 现在输入这%d个任务的信息\n",n);int pre;int sum = 0;double sum1=0;for(i=0;i<n;i++){getchar();printf("\n");printf(" 第%d个: ",i+1);scanf("%s",work[i].name);scanf("%d:%d",&h,&m);work[i].Ctime=h*60+m;scanf("%d",&work[i].Rtime);if(i==0){work[i].Stime=work[i].Ctime;work[i].Etime=work[i].Stime+work[i].Rtime;work[i].Ttime=work[i].Rtime;work[i].circle=(1.0*work[i].Ttime)/(1.0*work[i].Rtime);pre=work[i].Etime;}else{work[i].Stime=max(work[i].Ctime,pre);work[i].Etime=work[i].Stime+work[i].Rtime;work[i].Ttime=work[i].Etime-work[i].Ctime;work[i].circle=(1.0*work[i].Ttime)/(1.0*work[i].Rtime);pre=work[i].Etime;}sum+=work[i].Ttime;sum1+=work[i].circle;}printf("\n");printf(" 先来先服务算法运行结果如下：\n\n");printf(" 作业名进入时间运行时间开始时间结束时间周转时间带权周转时间\n\n");for(i=0;i<n;i++)printf(" %s %02d : %02d %4d %02d : %02d %02d : %02d %4d %.3lf\n\n",work[i].name, work[i].Ctime/60,work[i].Ctime%60, work[i].Rtime, work[i].Stime/60, work[i].Stime%60, work[i].Etime/60,work[i].Etime%60,work[i].Ttime,work[i].circle);printf(" 作业的平均周转时间为： %.3lf分钟\n\n",(1.0*sum)/(1.0*n));printf(" 作业的平均带权周期为： %.3lf\n\n",sum1/(1.0*n));printf(" 先来先服务算法体验结束\n\n");}void SJF(){bool vis[N];int n,h,m,i,j;printf("******************************\n\n");printf(" 欢迎体验最短作业优先算法 \n\n");printf(" 请输入作业的个数： ");scanf("%d",&n);printf("\n\n");printf(" 首先请按作业进入输入井时间的先后输入*时间相同的按执行时间长短输入*\n\n");printf(" 每个任务的格式为：\n\n 作业名称作业进入输入井的时间作业运行时间\n\n");printf(" ps: 进入输入井的时间格式为 h:m\n\n");printf(" 现在输入这%d个任务的信息\n\n",n);for( i=0;i<n;i++){getchar();printf("\n");printf(" 第%d个: ",i+1);scanf("%s",work[i].name);scanf("%d:%d",&h,&m);work[i].Ctime=h*60+m;scanf("%d",&work[i].Rtime);}priority_queue<int, vector<int>, cmp> Que;memset(vis,0,sizeof(vis));int num=0;int pre=0;int sum=0;double sum1=0;while(num<n){vis[num]=true;Que.push(num);num++;while(!Que.empty()){int u=Que.top();Que.pop();work[u].Stime=max(pre,work[u].Ctime);//作业开始时间work[u].Etime=work[u].Stime+work[u].Rtime;work[u].Ttime=work[u].Etime-work[u].Ctime;work[u].circle=(1.0*work[u].Ttime)/(1.0*work[u].Rtime);sum+=work[u].Ttime;sum1+=work[u].circle;pre=work[u].Etime;if(num<n){int tag=0;for( j=1;j<n;j++){if(vis[j]==false&&work[u].Etime>=work[j].Ctime){Que.push(j);num++;vis[j]=true;tag=1;}}}}}printf("\n");printf(" 先来先服务算法运行结果如下：\n\n");printf(" 作业名进入时间运行时间开始时间结束时间周转时间带权周转时间\n\n");for(i=0;i<n;i++)printf(" %s %02d : %02d %4d %02d : %02d %02d : %02d %4d %.3lf\n\n",work[i].name, work[i].Ctime/60,work[i].Ctime%60, work[i].Rtime, work[i].Stime/60, work[i].Stime%60, work[i].Etime/60,work[i].Etime%60,work[i].Ttime,work[i].circle);printf(" 作业的平均周转时间为： %.3lf分钟\n\n",(1.0*sum)/(1.0*n));printf(" 作业的平均带权周期为： %.3lf\n\n",sum1/(1.0*n));printf(" 先来先服务算法体验结束\n\n");}void HRN(){bool vis[N];int n,h,m,i,j,k;printf("******************************\n\n");printf(" 欢迎体验最短作业优先算法 \n\n");printf(" 请输入作业的个数： ");scanf("%d",&n);printf("\n\n");printf(" 首先请按作业进入输入井时间的先后输入*时间相同的按执行时间长短输入*\n\n");printf(" 每个任务的格式为：\n\n 作业名称作业进入输入井的时间作业运行时间\n\n");printf(" ps: 进入输入井的时间格式为 h:m\n\n");printf(" 现在输入这%d个任务的信息\n\n",n);for( i=0;i<n;i++){getchar();printf("\n");printf(" 第%d个: ",i+1);scanf("%s",work[i].name);scanf("%d:%d",&h,&m);work[i].Ctime=h*60+m;scanf("%d",&work[i].Rtime);}work[0].Stime=work[0].Ctime;work[0].Etime=work[0].Stime+work[0].Rtime;work[0].Ttime=work[0].Rtime;work[0].circle=1;int sum=work[0].Ttime;double sum1=work[0].circle;int pre=work[0].Etime;memset(vis,0,sizeof(vis));vis[0]=true;for(i=1;i<n;i++){k=-1;double max1=1;for(j=1;j<n;j++){if(vis[j]==false&&work[j].Ctime<=pre){int startime=pre;// cout << startime << endl;int ttime=(startime+work[j].Rtime-work[j].Ctime);//预计周转时间//cout << ttime << endl;double rt=(1.0*ttime)/(1.0*work[j].Rtime);if(rt>max1){max1=rt;k=j;}}}//printf("%.3lf\n",max1);if(k!=-1){vis[k]=true;work[k].Stime=max(pre,work[k].Ctime);work[k].Etime=work[k].Stime+work[k].Rtime;work[k].Ttime=work[k].Etime-work[k].Ctime;work[k].circle=(1.0*work[k].Ttime)/(1.0*work[k].Rtime);pre=work[k].Etime;sum+=work[k].Ttime;sum1+=work[k].circle;}else{for(j=1;j<n;j++)if(vis[j]==false)break;work[j].Stime=work[j].Ctime;work[j].Etime=work[j].Stime+work[j].Rtime;work[j].Ttime=work[j].Rtime;work[j].circle=1;vis[j]=true;pre=work[j].Etime;sum+=work[j].Ttime;sum1+=work[j].circle;}}printf("\n");printf(" 先来先服务算法运行结果如下：\n\n");printf(" 作业名进入时间运行时间开始时间结束时间周转时间带权周转时间\n\n");for(i=0;i<n;i++)printf(" %s %02d : %02d %4d %02d : %02d %02d : %02d %4d %.3lf\n\n",work[i].name, work[i].Ctime/60,work[i].Ctime%60, work[i].Rtime, work[i].Stime/60, work[i].Stime%60, work[i].Etime/60,work[i].Etime%60,work[i].Ttime,work[i].circle);printf(" 作业的平均周转时间为： %.3lf分钟\n\n",(1.0*sum)/(1.0*n));printf(" 作业的平均带权周期为： %.3lf\n\n",sum1/(1.0*n));printf(" 最高响应比算法体验结束\n\n");}八、实验结果分析数据：job1 8:00 120job2 8:50 50job3 9:00 10job4 9:50 20先来先服务算法：job1 08 : 00 120 08 : 00 10 : 00 120 1.000 job2 08 : 50 50 10 : 00 10 : 50 120 2.400job3 09 : 00 10 10 : 50 11 : 00 120 12.000job4 09 : 50 20 11 : 00 11 : 20 90 4.500平均周转时间为 112.5平均带权周转时间为 4.975分析：job1先进入输入井，结束时间就为10:00那么job2第二个进入输入井，他只能等job1执行完了之后才能执行故job2的开始时间为10:00，job3,job4 同理最短作业优先：job1 08 : 00 120 08 : 00 10 : 00 120 1.000job2 08 : 50 50 10 : 30 11 : 20 150 3.000job3 09 : 00 10 10 : 00 10 : 10 70 7.000job4 09 : 50 20 10 : 10 10 : 30 40 2.000平均周转时间为 95平均带权周转时间为 3.250分析：job1先运行，结束时间为10:00,那么在10:00之前进入输入井的job2、job3、job4都进入优先队列，运行时间最短的job3出队，之后job4出队，最后job2调用最高响应比：job1 08 : 00 120 08 : 00 10 : 00 120 1.000 job2 08 : 50 50 10 : 10 11 : 00 130 2.600job3 09 : 00 10 10 : 00 10 : 10 70 7.000job4 09 : 50 20 11 : 00 11 : 20 90 4.500平均周转时间为 102.500平均带权周转时间为 3.775分析：job1先调用，根据job1的结束时间10:00,选择10：00之前的任务都进入输入井，那么job2、job3、job4都进入输入井，之后输入井中的每一个任务都以job1为基础计算出相对于job1的响应比，最高的开始执行，执行完以后又以执行完以后的任务为基础计算所有输入井中的任务的响应比，选择最高的运行，如此运行直到结束九实验改进意见与建议实验比较简单，但是细节地方很烦，注意代码风格，多加注释可能有一些数据没有考虑到，一些比较特殊的数据可能会出现错误。