短作业优先算法试验报告

短进程优先实验报告1. 引言短进程优先（Shortest Job First，简称SJF）是一种常见的进程调度算法，其核心思想是优先调度执行估计执行时间最短的进程。

在实际应用中，SJF算法能够有效提高系统的响应速度和吞吐量，因此在操作系统领域得到广泛应用。

本实验主要通过使用模拟调度程序，对短进程优先算法进行测试和验证，以探讨其行为特性和性能表现。

2. 实验内容本实验基于一个简单的模拟调度程序，该程序能够接收一组进程及其估计执行时间作为输入，并根据SJF算法进行进程调度。

实验的主要内容包括：- 设计并实现短进程优先调度算法- 编写测试用例并模拟进程调度- 分析调度结果并评估算法的性能3. 实验设计3.1 短进程优先调度算法短进程优先调度算法的核心在于估计每个进程的执行时间，并根据执行时间进行进程排序。

为了实现该算法，我们设计了以下步骤：1. 输入一组进程及其估计执行时间2. 按照进程的估计执行时间对进程进行排序，以便进行优先级计算3. 根据短进程优先原则，选择执行时间最短的进程执行4. 更新进程的执行时间和优先级等信息5. 重复第3和第4步，直到所有进程执行完毕3.2 测试用例设计为了全面测试短进程优先调度算法的性能，我们设计了以下几个测试用例：1. 一组进程的执行时间各不相同2. 几组进程的执行时间相同，但到达时间不同3. 几组进程的执行时间和到达时间都不相同通过以上测试用例的设计，我们能够测试算法在不同情况下的调度表现，包括吞吐量、平均等待时间等。

4. 实验结果根据实验设计，我们进行了多次测试，并统计了各组测试用例下的调度结果。

下表是三组测试用例的部分调度结果示例：进程号执行时间到达时间完成时间周转时间等待时间P1 5 0 10 10 0P2 3 1 4 3 0P3 8 2 14 12 4进程号执行时间到达时间完成时间周转时间等待时间P1 3 0 3 3 0P2 3 0 6 6 3P3 4 0 10 10 6进程号执行时间到达时间完成时间周转时间等待时间P1 4 0 4 4 0P2 4 1 8 7 3P3 5 2 13 11 6通过统计分析，我们得到了以下结论：- 在执行时间不同的情况下，短进程优先调度算法能够显著提高系统的吞吐量和响应时间。

操作系统调度算法实验报告摘要：本篇实验报告旨在研究和分析不同的操作系统调度算法对系统性能的影响。

通过实验，我们对先来先服务调度算法、短作业优先调度算法和时间片轮转调度算法进行了比较和评估。

实验结果表明，不同的调度算法对系统响应时间、吞吐量和公平性等方面都有不同的影响。

一、引言操作系统的调度算法是管理计算机资源的关键部分之一。

调度算法的好坏直接影响着系统的性能和用户体验。

本实验旨在通过模拟不同的调度算法，评估其对系统的影响，以便选择最适合特定环境的调度算法。

二、实验方法本实验使用了一个模拟的操作系统调度器，通过调度器模拟不同的进程到达和执行过程。

我们选择了三种常见的调度算法进行比较和评估。

1. 先来先服务（First-Come, First-Served）调度算法先来先服务调度算法按照进程到达的先后顺序进行调度。

当一个进程到达后，它将占用处理器直到该进程执行完毕。

我们记录了每个进程的到达时间、执行时间和完成时间，并计算了系统的平均等待时间和平均周转时间。

2. 短作业优先（Shortest Job First）调度算法短作业优先调度算法按照进程执行时间的长短进行调度。

当一个进程到达后，系统会选择执行剩余执行时间最短的进程。

我们同样记录了每个进程的到达时间、执行时间和完成时间，并计算了系统的平均等待时间和平均周转时间。

3. 时间片轮转（Round Robin）调度算法时间片轮转调度算法将处理器时间分成若干个时间片，每个进程只能占用一个时间片。

当一个进程用完一个时间片后，它排到队列的末尾等待下一个时间片。

我们选择了不同的时间片长度，并观察了系统的响应时间和吞吐量。

三、实验结果与分析我们通过多组实验数据对不同的调度算法进行了评估。

以下是实验结果的分析：1. 先来先服务调度算法根据实验数据，我们发现先来先服务调度算法对长作业具有较高的等待时间和周转时间。

这是因为当一个长作业到达后，其他短作业需要等待该作业执行完毕才能获得处理器资源。

操作系统调度算法实验报告
本实验旨在研究不同操作系统调度算法在实际应用中的表现和影响。

我们选择了三种常见的调度算法进行对比分析，分别是先来先服务（FCFS）、最短作业优先（SJF）和时间片轮转（RR）。

1. 实验准备
在开始实验之前，我们首先搭建了一个简单的模拟环境，包括一个CPU和多个进程。

每个进程具有不同的执行时间，以便模拟不同情况
下的调度效果。

2. 先来先服务（FCFS）
先来先服务是最简单的调度算法之一，即根据进程到达的顺序依次
执行。

实验结果显示，FCFS算法适用于处理大量长作业，但当出现短
作业时会导致平均等待时间较长。

3. 最短作业优先（SJF）
最短作业优先算法会优先执行执行时间最短的进程，以减少平均等
待时间。

在我们的实验中，SJF算法表现出色，尤其在短作业较多的情
况下，能够显著提高系统的响应速度。

4. 时间片轮转（RR）
时间片轮转算法将CPU时间分配给每个进程，每个进程执行一个
时间片后轮转到下一个进程。

然而，RR算法可能导致上下文切换频繁，
影响系统效率。

在实验中，我们发现RR算法在处理多任务时效果较好，但在处理长时间任务时表现一般。

5. 实验总结
通过对三种调度算法的实验比较，我们可以看出不同算法在不同情
况下有着不同的优势和劣势。

在实际应用中，需要根据具体情况选择
合适的调度算法，以提高系统的性能和效率。

希望本实验能为操作系
统调度算法的研究提供一定的参考价值。

调度的调度算法实验报告调度的调度算法实验报告引言：调度是计算机科学中一个重要的概念，它涉及到任务分配、资源管理和优化等方面。

调度算法则是实现调度的关键，它决定了任务的执行顺序和资源的分配方式。

在本次实验中，我们将探讨几种常见的调度算法，并通过实验对其性能进行评估和比较。

一、先来先服务算法（FCFS）先来先服务算法是最简单的调度算法之一，它按照任务到达的先后顺序进行处理。

实验中，我们模拟了一个任务队列，每个任务有不同的执行时间。

通过实验结果可以看出，FCFS算法的优点是简单易懂，但当任务的执行时间差异较大时，会导致平均等待时间较长。

二、最短作业优先算法（SJF）最短作业优先算法是一种非抢占式调度算法，它根据任务的执行时间来进行排序。

实验中，我们将任务按照执行时间从短到长进行排序，并进行调度。

实验结果显示，SJF算法的优点是能够最大程度地减少平均等待时间，但当任务的执行时间无法预测时，该算法可能会导致长任务等待时间过长的问题。

三、时间片轮转算法（RR）时间片轮转算法是一种抢占式调度算法，它将任务分为多个时间片，并按照顺序进行调度。

实验中，我们设置了每个时间片的长度，并将任务按照到达顺序进行调度。

实验结果表明，RR算法的优点是能够公平地分配资源，但当任务的执行时间超过一个时间片时，会导致上下文切换频繁，影响系统的性能。

四、最高响应比优先算法（HRRN）最高响应比优先算法是一种动态调度算法，它根据任务的等待时间和执行时间来计算响应比，并选择响应比最高的任务进行调度。

实验中，我们根据任务的到达时间、执行时间和等待时间计算响应比，并进行调度。

实验结果显示，HRRN算法能够在一定程度上平衡长任务和短任务的等待时间，但当任务的执行时间过长时，会导致其他任务的等待时间过长。

五、多级反馈队列算法（MFQ）多级反馈队列算法是一种综合性的调度算法，它将任务分为多个队列，并根据任务的执行情况进行调度。

实验中，我们设置了多个队列，并根据任务的执行时间和等待时间进行调度。

先来先服务调度和最短作业优先调度算法实验报告实验报告一、实验目的本实验旨在通过编写代码实现先来先服务调度算法和最短作业优先调度算法，以深入理解和掌握这两种调度算法的原理和实现方法。

二、实验方法和原理1.先来先服务调度算法（FCFS）2.最短作业优先调度算法（SJF）最短作业优先调度算法是根据作业所需的运行时间进行调度的。

当一个作业到达并获得CPU后，系统会选择剩余运行时间最短的作业进行处理，这样可以最大化地提高系统的吞吐量。

三、实验过程与结果1.先来先服务调度算法的实现我们先定义一个作业类Job，其中包含作业名称、到达时间和运行时间等属性。

首先根据到达时间对作业队列进行排序，然后按照顺序执行作业，记录每个作业的开始时间、结束时间和周转时间等指标。

下面是先来先服务调度算法的代码实现部分：```pythonclass Job: = namedef fcfs_scheduler(jobs):for job in sorted_jobs:#创建作业队列jobs =Job("Job1", 0, 3),Job("Job2", 1, 4),Job("Job3", 2, 2),Job("Job4", 4, 1)#调度作业fcfs_scheduler(jobs)#输出结果for job in jobs:```运行以上代码，会得到作业的开始时间、结束时间和周转时间等信息。

2.最短作业优先调度算法的实现最短作业优先调度算法需要知道每个作业的运行时间，而这个信息在实际情况中是未知的。

因此，我们可以先按到达时间对作业队列进行排序，然后在每个时间片中选择剩余运行时间最短的作业进行执行。

下面是最短作业优先调度算法的代码实现部分：```pythondef sjf_scheduler(jobs):while True:if not remaining_jobs:break#创建作业队列jobs =Job("Job1", 0, 3),Job("Job2", 1, 4),Job("Job3", 2, 2),Job("Job4", 4, 1)#调度作业sjf_scheduler(jobs)#输出结果for job in jobs:```运行以上代码，会得到相应的作业调度结果。

操作系统》实验一实验报告【实验题目】：先来先服务FCFS 和短作业优先SJF进程调度算法【实验目的】通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。

【实验内容】问题描述：设计程序模拟进程的先来先服务FCFS 和短作业优先SJF 调度过程。

假设有n个进程分别在T1, ⋯,T n时刻到达系统，它们需要的服务时间分别为S1, ⋯,S n。

分别采用先来先服务FCFS和短作业优先SJF 进程调度算法进行调度，计算每个进程的完成时间，周转时间和带权周转时间，并且统计n 个进程的平均周转时间和平均带权周转时间。

程序要求如下：1）进程个数n；每个进程的到达时间T1, ⋯,T n 和服务时间S1, ⋯,S n；选择算法1-FCFS，2-SJF。

2）要求采用先来先服务FCFS 和短作业优先SJF分别调度进程运行，计算每个进程的周转时间，带权周转时间，并且计算所有进程的平均周转时间，带权平均周转时间；3）输出：要求模拟整个调度过程，输出每个时刻的进程运行状态，如“时刻3：进程 B 开始运行”等等；4）输出：要求输出计算出来的每个进程的周转时间，带权周转时间，所有进程的平均周转时间，带权平均周转时间【实验过程】#include<iostream> using namespace std;#define MaxNum 100int ArrivalTime[MaxNum];double ServiceTime[MaxNum]; double FinishTime[MaxNum]; double WholeTime[MaxNum];double AVEWholeTime[MaxNum]; doubleAVEWeightWholeTime[MaxNum]; double WeightWholeTime[MaxNum]; double AverageWT_FCFS,AverageWT_SJF; doubleAverageWWT_FCFS,AverageWWT_SJF; doubleAllTime,WeightAllTime;double a[MaxNum];int b[MaxNum];int c[MaxNum]; int d[MaxNum]; void FCFS(); void SJF();void FCFS(){int ProcessNum;cout<<" --------- 先来先服务算法"<<endl;cout<<" 请输入进程个数："; cin>>ProcessNum; cout<<" 输入进程到达时间："; cout<<endl;for(int i=0;i<ProcessNum;i++){cin>>ArrivalTime[i];//cout<<endl;}cout<<endl;cout<<"请输入进程服务时间：cout<<endl;for(int i=0;i<ProcessNum;i++){cin>>ServiceTime[i];//cout<<endl;}cout<<endl;for(int i=0;i<ProcessNum;i++){FinishTime[i]=ServiceTime[i];}for(int i=0;i<ProcessNum;i++){FinishTime[i+1]=FinishTime[i]+FinishTime[i+1]; }for(int i=0;i<ProcessNum-1;i++){cout<<"时刻"<<FinishTime[i]<<": 第"<<i+2<<" 个进程开始运行。

实验短作业优先SJF进程调度算法模拟一、实验目的模拟单处理器系统的进程调度，采用短作业优先的进程调度算法作为进程设计算法，以加深对进程的概念及进程调度算法的理解．二、实验内容如进程信息如下：struct PCB pcb[N]=进程名到达时间运行时间完成时间周转时间A 0 4 4 4B 1 3 7 6C 2 5 16 14D 15 2 18 3E 4 4 11 7#include <stdio.h>#include <string.h>#include <stdlib.h>#include <conio.h>#define N 5struct PCB{char name[8];int arrive_time;int run_time;int finish_time;int zhouzhuan_time;float daiquan_time;};float pinjun_zhouzhuan_time;float pinjun_daiquan_time;struct PCB pcb[N] ={{"DDD",3,2},{"AAA",0,4},{"BBB",1,3},{"CCC",2,5},{"EEE",4,4}}; void output(){ printf("进程名到达时间运行时间完成时间周转时间带权周转时间\n");for(int i=0;i<N;i++){printf(" %s %d %d %d %d %f\n",pcb[i].name,pcb[i].arrive_time,pcb[i].run_time,pcb[i].finis h_time,pcb[i].zhouzhuan_time,pcb[i].daiquan_time);}}void sortPCB(){struct PCB temp;int i,j;for(i=0;i<N-1;i++)for(j=i+1;j<N;j++)if(pcb[i].arrive_time>pcb[j].arrive_time){temp=pcb[j];pcb[j]=pcb[i];pcb[i]=temp;}}void main(){int i ;printf(" 进程初始状态\n");output();printf(" 进程按到达时间排序后的状态\n");sortPCB();output();for(i=0;i<N;i++){//下面计算本进程的完成时间if(i==0)pcb[i].finish_time=pcb[i].run_time+pcb[i].arrive_time;elseif(pcb[i].arrive_time<pcb[i-1].finish_time)pcb[i].finish_time=pcb[i-1].finish_time+pcb[i].run_time;elsepcb[i].finish_time=pcb[i].arrive_time+pcb[i].run_time;//下面计算本进程的周转时间pcb[i].zhouzhuan_time=pcb[i].finish_time-pcb[i].arrive_time;//下面计算本进程的带权周转时间pcb[i].daiquan_time=(float)pcb[i].zhouzhuan_time/pcb[i].run_time;}int total_zhouzhuan_time=0;float total_daiquan_time=0;for(i=0;i<N;i++){total_zhouzhuan_time+=pcb[i].zhouzhuan_time;total_daiquan_time+=pcb[i].daiquan_time;}pinjun_zhouzhuan_time=(float)total_zhouzhuan_time/N;pinjun_daiquan_time=total_daiquan_time/N;printf(" 计算后的结果输出\n");output();printf("平均周转时间为：%f\n",pinjun_zhouzhuan_time);printf("平均带权周转时间为：%f\n",pinjun_daiquan_time); }。

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

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

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

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

（3）响应比高者优先算法：是在每次调度前都要计算所有被选作业（在后备队列中）的响应比，然后选择响应比最高的作业执行。

2、编写并调度一个多道程序系统的作业调度模拟程序。

作业调度算法：采用基于先来先服务的调度算法。

可以参考课本中的方法进行设计。

对于多道程序系统，要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求。

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

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

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

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

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

3)流程图:二.最短作业优先算法三.高响应比算法图一.先来先服务流程图4)源程序:#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\t计算机学院软件四班\n");printf("\t\t\t\t\t蓝小花\n");printf("\t\t\t\t\t完成日期：2006年11月17号");printf("\n\n\n\t\t请输入任意键进入演示过程\n");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("开始运行时刻：%d\n",q->starttime);printf("完成时刻：%d\n",q->finishtime);printf("周转时间：%f\n",q->cycletime);printf("带权周转时间：%f\n",q->cltime);printf("相应比:%f\n",q->super);getch();}else // 显示先来先服务,最短作业优先算法调度后作业的运行情况{printf("\n作业%s正在运行，估计其运行情况：\n",q->name); printf("开始运行时刻：%d\n",q->starttime);printf("完成时刻：%d\n",q->finishtime);printf("周转时间：%f\n",q->cycletime);printf("带权周转时间：%f\n",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 has been finished!\npress any key to continue...\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)/p adv->needtimepadv=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++;//printf("\ntime=%d:\tno JCB submib...wait...",time);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--; //printf("\ntime=%d:\tno JCB submib...wait...",time);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();}5)调试结果:1.选择操作的界面2.输入操作初始信息:3.先来先服务算法作业调度结果: (调度顺序:a->b->c->d->e)4.最短作业优先算法作业调度结果(调度顺序: a->d->b->e->c)5.高响应比算法作业调度结果: (调度顺序 a->b->d->c->e)<二>多道处理系统作业调度1)多道处理程序作业调度实验的源程序: duodao.c执行程序: duodao.exe2)实验分析：采用多道程序设计方法的操作系统，在系统中要经常保留多个运行的作业，以提高系统效率。

作业调度算法模拟一、课题内容和要求常见的作业调度算法有先来先服务算法、最短作业优先算法、响应比优先调度算法。

(1)参考操作系统教材理解这3种算法。

(2)实现这3个算法。

(3)已知若干作业的到达时间和服务时间，用实现的算法计算对该组作业进行调度的平均周转时间Ttime和平均带权周转时间WTtime。

(4)作业的到达时间和服务时间可以存放在文本文件record.txt中。

(5)设计简单的交互界面，演示所设计的功能。

(可以使用MFC进行界面的设计) （6）可根据自己能力，在完成以上基本要求后，对程序功能进行适当扩充。

二、需求分析模拟实现作业调度算法，包括：FCFS（先来先服务算法）、SJF（短作业优先算法）、HRN（最高响应比优先算法）、HPF（基于优先数调度算法）。

先来先服务算法：按照各个作业进入系统（输入井）的自然次序来调度算法。

短作业优先算法：优先调度并处理短作业。

所谓的“短作业”并不是指物理作业长度短，而是指作业的运行时间短。

最高响应比优先算法：优先调度并处理响应比最高的作业。

三、概要设计函数中一些类：1、2、先来先服务：3、最短作业优先：4、最高响应比：四、详细设计1、程序代码MFC头文件a.h内容：const int defMaxJobNumber = 10; //作业数量的最大值class Time //时间类{public:int hour;int minute;};class Job//作业类{public:int ID; //作业编号Time enter; //进入时间int requesttime; //估计运行时间int priority; //优先数Time start; //开始时间Time end; //结束时间int Ttime; //周转时间double WTtime; //带权周转时间};class schedule //调度类{public:int size; //作业数Job *job; //作业数组int *r; //排序用数组int Differ(Time t1,Time t2) //求两个时刻间的时间差t2-t1{int borrow = (t2.minute<t1.minute) ? 1 : 0;return ((t2.hour-t1.hour-borrow)*60+(borrow*60+t2.minute-t1.minute));}public:schedule() //构造函数{size = 0;job = new Job[defMaxJobNumber];r = new int[defMaxJobNumber-1];}void readFile() //从文件读信息{ifstream txtfile;txtfile.open("record.txt");int i = 0;int entertime;while(!txtfile.eof()){txtfile>>job[i].ID>>entertime>>job[i].requesttime>>job[i].priority;job[i].enter.hour = entertime / 100; //取小时job[i].enter.minute = entertime % 100; //取分钟i++;size++;}txtfile.close();}void FCFS()//先来先服务(First Come First Serve){int hour,minute,carry;job[0].start = job[0].enter;hour = job[0].requesttime / 60;minute = job[0].requesttime % 60;job[0].end.minute = (job[0].start.minute + minute) % 60;carry = (job[0].start.minute + minute) / 60; //carry是分钟累积超过60商job[0].end.hour = job[0].start.hour + hour + carry;job[0].Ttime = job[0].requesttime;job[0].WTtime = ((double)job[0].Ttime) / job[0].requesttime;for(int i=1;i<size;i++){job[i].start = job[i-1].end;hour = job[i].requesttime / 60;minute = job[i].requesttime % 60;job[i].end.minute = (job[i].start.minute + minute) % 60;carry = (job[i].start.minute + minute) / 60;job[i].end.hour = job[i].start.hour + hour + carry;job[i].Ttime = Differ(job[i].enter,job[i].end); //周转时间job[i].WTtime = ((double)job[i].Ttime) / job[i].requesttime; //带权周转时间}}void SJF()//短作业优先(Shortest Job First){int hour,minute,carry;job[0].start = job[0].enter;hour = job[0].requesttime / 60;minute = job[0].requesttime % 60;job[0].end.minute = (job[0].start.minute + minute) % 60;carry = (job[0].start.minute + minute) / 60; //carry是分钟累积超过60的商job[0].end.hour = job[0].start.hour + hour + carry;job[0].Ttime = job[0].requesttime; //周转时间job[0].WTtime = ((double)job[0].Ttime) / job[0].requesttime; //带权周转时间for(int i=1;i<size;i++)r[i] = i;for(i=1;i<size-1;i++) //按照作业运行时间从低到高排序{int index = i;for(int j=i+1;j<size;j++)if(job[r[j]].requesttime<job[r[index]].requesttime)index = j;if(index!=i){int w = r[i];r[i] = r[index];r[index] = w;}}int dest=0;for(i=1;i<size;i++) //按排序后的作业序继续执行{int index = r[i];job[index].start = job[dest].end;hour = job[index].requesttime / 60;minute = job[index].requesttime % 60;job[index].end.minute = (job[index].start.minute + minute) % 60;carry = (job[index].start.minute + minute) / 60;job[index].end.hour = job[index].start.hour + hour + carry;job[index].Ttime = Differ(job[index].enter,job[index].end);job[index].WTtime = ((double)job[index].Ttime) / job[index].requesttime;dest = index;}}void HRN() //最高响应比优先(Highest Response_ratio Next){int hour,minute,carry;job[0].start = job[0].enter;hour = job[0].requesttime / 60;minute = job[0].requesttime % 60;job[0].end.minute = (job[0].start.minute + minute) % 60;carry = (job[0].start.minute + minute) / 60; //carry是分钟累积超过60的商job[0].end.hour = job[0].start.hour + hour + carry;job[0].Ttime = job[0].requesttime; //周转时间job[0].WTtime = ((double)job[0].Ttime) / job[0].requesttime; 带权周转时间int dest=0;for(int i=1;i<size;i++)r[i] = i;for(i=1;i<size;i++){int index = i;for(int j=i+1;j<size;j++) //按照响应比从大到小排序if(((double)Differ(job[r[j]].enter,job[dest].end))/job[r[j]].requesttime>((double)Differ(job[r[index]].enter,job[dest].end))/job[r[index]].requesttime)//响应比=作业周转时间/作业处理时间index = j;if(index!=i){int w = r[i];r[i] = r[index];r[index] = w;}//按排序后的作业序继续执行index = r[i];job[index].start = job[dest].end;hour = job[index].requesttime / 60;minute = job[index].requesttime % 60;job[index].end.minute = (job[index].start.minute + minute) % 60;carry = (job[index].start.minute + minute) / 60;job[index].end.hour = job[index].start.hour + hour + carry;job[index].Ttime = Differ(job[index].enter,job[index].end);job[index].WTtime = ((double)job[index].Ttime) / job[index].requesttime;dest = index;}}};五、测试数据及其结果分析从文本文件中读取数据（书上的例子）：1 800 120 22 850 50 33 900 10 14 950 20 4输出的平均周转时间、平均带权周转时间结果正确。

短作业优先调度和时间片轮转调度算法Prepared on 22 November 2020电子科技大学实验报告学生姓名：胡钟文学号：指导教师：罗惠琼一、实验室名称：主楼A2-412二、实验项目名称：进程调度算法的设计三、实验原理：短作业（进程）优先调度算法：短作业调度算法是从后备队列中选择一个或者若干个估计运行时间最短的作业，将他们调入内存运行。

而短进程优先调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或者发生某事件而被阻塞放弃处理机时再重新调度。

时间片轮转法：系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。

当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的队尾；然后，再把处理机分配给就绪队列中的新的队首进程，同时也让它执行一个时间片。

这样就可以保证就绪队列中的所有进程在一个给定的时间内均能获得一时间片的处理机执行时间。

四、实验目的：通过对进程调度算法的设计，深入理解进程调度的原理五、实验内容：1．编写程序实现SJ（P）F算法2．编写程序实现RR算法六、实验器材（设备、元器件）：装有VC++的PC机一台七、实验步骤：1．打开VC，设计编写程序的源代码2．编译运行程序的源代码3．分析检验程序的结果是否正确4．总结实验结果及结论短进程优先调度源代码：#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].servicetime);}}void Print(sjf *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float dqzztime,int N){int k;printf("run order:");printf("%s",p[0].name);for(k=1;k<N;k++){printf("-->%s",p[k].name);}printf("\nthe process's information:\n");printf("\nname\tarrive\tservice\tstart\tfinish\tzz\tdqzz\n");for(k=0;k<=N-1;k++){ printf("%s\t%\t%\t%\t%\t%\t%\t\n",p[k].name,p[k].arrivetime,p[k].servicetime,p[k].starttime ,p[k].finishtime,p[k].zztime,p[k].dqzztime);}}rrivetime<p[j].arrivetime){sjf temp;temp=p[i];p[i]=p[j];p[j]=temp;}}tarttime=p[k].arrivetime;p[k].finishtime=p[k].arrivetime+p[k].servicetime;}else{p[k].starttime=p[k-1].finishtime;p[k].finishtime=p[k-1].finishtime+p[k].servicetime;}}for(k=0;k<=N-1;k++){p[k].zztime=p[k].finishtime-p[k].arrivetime;p[k].dqzztime=p[k].zztime/p[k].servicetime;}}void sjff(sjf *p,int N){floatarrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0;inishtime=p[m].arr ivetime+p[m].servicetime;elsep[m].finishtime=p[m-1].finishtime+p[m].servicetime;int i=0;for(int n=m+1;n<=N-1;n++){if(p[n].arrivetime<=p[m].finishtime)ervicetime;int next=m+1;ervicetime<min){min=p[k+1].servicetime;next=k+1;}}sjf temp;temp=p[m+1];p[m+1]=p[next];p[next]=temp;}deal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N); Print(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N); }void main(){ int N;printf("------短作业优先调度算法------\n");printf("input the process's number:\n");scanf("%d",&N);input(a,N);sjf *b=a;sjf *c=a;sjff(b,N);}时间片轮转法源代码：#include <>#define M 5 D=-1;}}int GetNum()D!=-1){j++;}}return j;}int GetReach(int time)eachTime<=time){a[i].ReachTime=100;return i;}}return -1;}int GetInsert()D==-1)return i;}return -1;}void Forward(int num)D=A[i+1].ID;A[i].TotalTime=A[i+1].TotalTime;}A[num-1].ID=-1;}void Process()D;K++;A[0].TotalTime--;=A[0].ID;=A[0].TotalTime;}void main(){int i;int time;int t=0;int reach;int insert;int num;printf("RR算法\n\n");INIT();for(i=0;i<M;i++){printf("请输入进程ID：");scanf("%d",&a[i].ID);printf("请输入到达时间：");scanf("%d",&a[i].ReachTime);printf("请输入服务时间：");scanf("%d",&a[i].TotalTime);}for(i=0;i<M;i++)otalTime;}for(i=0;i<50;i++)D=a[reach].ID;A[insert].TotalTime=a[reach].TotalTime;num=GetNum();if(num==1)continue;D=;A[num-1].TotalTime=;}}}elseD=-1;}}else if(num==0)continue;D=;A[num-1].TotalTime=;}}}}printf("\n");printf("调度顺序为：\n");Myprintf;for(i=0;i<50;i++){if(queue[i]!=-1)printf("|%2d ",queue[i]);}printf("|\n");Myprintf;printf("\n");}八、实验数据及结果分析：短作业优先调度算法的实验结果：时间片轮转调度算法结果：九、实验结论：本次实验成功的完成了短作业优先调度算法和轮转时间片调度算法的模拟，通过本次实验我们了解到短作业优先调度算法不利于长作业的处理，因为长作业将长期得不到处理，而轮转时间片调度算法则解决了这一问题。