提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
目录
题目：
第1关：先来先服务调度算法
任务描述
本关任务：编写一个先来先服务器调度算法解决一个实际的进程调度问题，并打印出每个进程的完成时间、周转时间和带权周转时间
相关知识
1.先来先服务调度算法
2.进程周转时间和平均周转时间的计算方法。
先来先服务调度算法FCFS
FCFS是最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，系统将按照作业到达的先后次序来进行调度，或者说它是优先考虑在系统中等待时间最长的作业
周转时间和带权周转时间
周转时间=完成时间-到达时间
带权周转时间=周转时间/执行时间
编程要求
给定一组进程的到达时间和服务时间，实现先来先服务调度算法，并打印出调度结果，包括每个进程的完成时间、周转时间和带权周转时间。
代码：
#include <stdio.h>
#include <string.h>
#define N 5
typedef struct JCB
{
char name[10];
int arriveTime; //到达时间
int serveTime; //服务时间
int finishTime; //完成时间
int aroundTime; //周转时间
float waroundTime; //带权周转时间
}PCB;
void input(PCB pcb[N])
{
strcpy(pcb[0].name,"A");
pcb[0].arriveTime = 0;
pcb[0].serveTime = 3;
strcpy(pcb[1].name,"B");
pcb[1].arriveTime = 2;
pcb[1].serveTime = 6;
strcpy(pcb[2].name,"C");
pcb[2].arriveTime = 4;
pcb[2].serveTime = 4;
strcpy(pcb[3].name,"D");
pcb[3].arriveTime = 6;
pcb[3].serveTime = 5;
strcpy(pcb[4].name,"E");
pcb[4].arriveTime = 8;
pcb[4].serveTime = 2;
int i = 0;
for(; i < N; ++i)
{
pcb[i].finishTime = 0;
pcb[i].aroundTime = 0;
pcb[i].waroundTime = 0;
}
}
void output(PCB pcb[N])
{
int i = 0;
printf("进程\t");
printf("完成时间\t");
printf("周转时间\t");
printf("带权周转时间\t\n");
for(; i < N; ++i)
{
printf("%s\t",pcb[i].name);
printf("%d\t\t",pcb[i].finishTime);
printf("%d\t\t",pcb[i].aroundTime);
printf("%f\t\t\n",pcb[i].waroundTime);
}
}
//先来先服务调度算法
void FCFS(PCB pcb[N])
{
//请补充先来先服务算法的实现代码
int finished=0;
int curTime=0;
while(finished<N)
{
int selected=-1;
int minTime=100;
int i=0;
for(;i<N;++i)
{
if(pcb[i].finishTime>0||pcb[i].arriveTime>curTime)
{
continue;
}
if(pcb[i].arriveTime<minTime)
{
minTime=pcb[i].arriveTime;
selected=i;
}
}//到达时间：curTime；
//pcb[selected].serveTime服务时间
pcb[selected].finishTime=curTime+pcb[selected].serveTime;//完成时间
pcb[selected].aroundTime=pcb[selected].finishTime-pcb[selected].arriveTime;//周转时间
pcb[selected].waroundTime=(float)pcb[selected].aroundTime/(float)pcb[selected].serveTime;//带权周转时间
curTime+=pcb[selected].serveTime;
finished+=1;
}
}
int main()
{
PCB pcb[N];
input(pcb);
FCFS(pcb);
printf("先来先服务FCFS:\n");
output(pcb);
printf("\n");
}
效果截图：
第2关：短作业优先调度算法
短作业优先调度算法SJF
SJF算法是以作业的长短来计算优先级，作业越短，其优先级越高。作业的长短是以作业所要求的运行时间来衡量的。SJF算法可以分别用于作业调度和进程调度，处理机优先选择运行时间短的作业或者进程。
周转时间和带权周转时间
周转时间=完成时间-到达时间 带权周转时间=周转时间/执行时间
编程要求
给定一组进程的到达时间和服务时间，实现短作业优先调度算法，并打印出调度结果，包括每个进程的完成时间、周转时间和带权周转时间。
代码：
#include <stdio.h>
#include <string.h>
#define N 5
typedef struct JCB
{
char name[10];
int arriveTime; //到达时间
int serveTime; //服务时间
int finishTime; //完成时间
int aroundTime; //周转时间
float waroundTime; //带权周转时间
}PCB;
void input(PCB pcb[N])
{
strcpy(pcb[0].name,"A");
pcb[0].arriveTime = 0;
pcb[0].serveTime = 3;
strcpy(pcb[1].name,"B");
pcb[1].arriveTime = 2;
pcb[1].serveTime = 6;
strcpy(pcb[2].name,"C");
pcb[2].arriveTime = 4;
pcb[2].serveTime = 4;
strcpy(pcb[3].name,"D");
pcb[3].arriveTime = 6;
pcb[3].serveTime = 5;
strcpy(pcb[4].name,"E");
pcb[4].arriveTime = 8;
pcb[4].serveTime = 2;
int i = 0;
for(; i < N; ++i)
{
pcb[i].finishTime = 0;
pcb[i].aroundTime = 0;
pcb[i].waroundTime = 0;
}
}
void output(PCB pcb[N])
{
int i = 0;
printf("进程\t");
printf("完成时间\t");
printf("周转时间\t");
printf("带权周转时间\t\n");
for(; i < N; ++i)
{
printf("%s\t",pcb[i].name);
printf("%d\t\t",pcb[i].finishTime);
printf("%d\t\t",pcb[i].aroundTime);
printf("%f\t\t\n",pcb[i].waroundTime);
}
}
//短作业优先调度算法
void SJF(PCB pcb[N])
{
for(int i=2;i<N;i++)
for(int j=i;j<N;j++)
{
while(pcb[i].serveTime>pcb[j].serveTime)
{
PCB a=pcb[i];
pcb[i]=pcb[j];
pcb[j]=a;
}
}
double time=pcb[0].arriveTime;
for(int i=0;i<N;i++)
{
time=time+pcb[i].serveTime;
pcb[i].finishTime=time;
pcb[i].aroundTime=pcb[i].finishTime-pcb[i].arriveTime;
double a=pcb[i].aroundTime,b=pcb[i].serveTime;
pcb[i].waroundTime=a/b;
}
for(int i=2;i<N;i++)
for(int j=i;j<N;j++)
{
while(pcb[i].arriveTime>pcb[j].arriveTime)
{
PCB a=pcb[i];
pcb[i]=pcb[j];
pcb[j]=a;
}
}
}
int main()
{
PCB pcb[N];
input(pcb);
SJF(pcb);
printf("短作业优先SJF:\n");
output(pcb);
printf("\n");
}
效果截图：
第3关：高响应比优先调度算法
高响应比优先调度算法HRRN
在批处理系统中，FCFS算法所考虑的只是作业的等待时间，而忽视了作业的运行时间。而SJF算法正好与之相反，只考虑作业的运行时间，而忽视了作业的等待时间。高响应比优先调度算法则是既考虑了作业的等待时间，又考虑作业运行时间的调度算法，因此既照顾了短作业，又不致使长作业的等待时间过长，从而改善了处理机调度的性能。 高响应比优先算法引入了响应比的概念，响应比定义如下 响应比=（等待时间+运行时间）/运行时间 高响应比优先算法每次选择响应比最高的进程，进程的响应比是动态变化的，既考虑了进程的等待时间，也考虑了进程的服务时间。
周转时间和带权周转时间
周转时间=完成时间-到达时间
带权周转时间=周转时间/执行时间
代码：
#include <stdio.h>
#include <string.h>
#define N 5
typedef struct JCB
{
char name[10];
int arriveTime; //到达时间
int serveTime; //服务时间
int finishTime; //完成时间
int aroundTime; //周转时间
float waroundTime; //带权周转时间
}PCB;
void input(PCB pcb[N])
{
strcpy(pcb[0].name,"A");
pcb[0].arriveTime = 0;
pcb[0].serveTime = 3;
strcpy(pcb[1].name,"B");
pcb[1].arriveTime = 2;
pcb[1].serveTime = 6;
strcpy(pcb[2].name,"C");
pcb[2].arriveTime = 4;
pcb[2].serveTime = 4;
strcpy(pcb[3].name,"D");
pcb[3].arriveTime = 6;
pcb[3].serveTime = 5;
strcpy(pcb[4].name,"E");
pcb[4].arriveTime = 8;
pcb[4].serveTime = 2;
int i = 0;
for(; i < N; ++i)
{
pcb[i].finishTime = 0;
pcb[i].aroundTime = 0;
pcb[i].waroundTime = 0;
}
}
void output(PCB pcb[N])
{
int i = 0;
printf("进程\t");
printf("完成时间\t");
printf("周转时间\t");
printf("带权周转时间\t\n");
for(; i < N; ++i)
{
printf("%s\t",pcb[i].name);
printf("%d\t\t",pcb[i].finishTime);
printf("%d\t\t",pcb[i].aroundTime);
printf("%f\t\t\n",pcb[i].waroundTime);
}
}
//高响应比优先调度算法
void HRRN(PCB pcb[N])
{
for(int i=3;i<N;i++)
for(int j=i;j<N;j++)
{
while(pcb[i].serveTime>pcb[j].serveTime)
{
PCB a=pcb[i];
pcb[i]=pcb[j];
pcb[j]=a;
}
}
double time=pcb[0].arriveTime;
for(int i=0;i<N;i++)
{
time=time+pcb[i].serveTime;
pcb[i].finishTime=time;
pcb[i].aroundTime=pcb[i].finishTime-pcb[i].arriveTime;
double a=pcb[i].aroundTime,b=pcb[i].serveTime;
pcb[i].waroundTime=a/b;
}
for(int i=2;i<N;i++)
for(int j=i;j<N;j++)
{
while(pcb[i].arriveTime>pcb[j].arriveTime)
{
PCB a=pcb[i];
pcb[i]=pcb[j];
pcb[j]=a;
}
}
}
int main()
{
PCB pcb[N];
input(pcb);
HRRN(pcb);
printf("高响应比优先HRRN:\n");
output(pcb);
}效果截图：
总结
提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了处理机调度（头歌实验）第1关：先来先服务调度算法。第2关：短作业优先调度算法。第3关：高响应比优先调度算法。
1888
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
