操作系统实验-先来先服务的调度算法和短作业优先Word格式.docx
《操作系统实验-先来先服务的调度算法和短作业优先Word格式.docx》由会员分享，可在线阅读，更多相关《操作系统实验-先来先服务的调度算法和短作业优先Word格式.docx（10页珍藏版）》请在冰点文库上搜索。
输出：
进程的完成时间、周转时间、带权周转时间
其中对于任意进程有：
周转时间=完成时间-到达时间
带权周转时间=周转时间/服务时间
因此，两个算法的关键是求完成时间
l数据结构及函数说明
使用的数据结构是数组，进程的名称、到达时间、服务时间、进程的完成时间、周转时间、带权周转时间分别对应于一个数组，这些数组长度相等.
structfcfs
//定义进程的结构体
{
charname[10];
//进程名
floatarrivetime;
//到达时间
floatservicetime;
//服务时间
floatstarttime;
//开始时间
floatfinishtime;
//完成时间
floatzztime;
//周转时间
floatdqzztime;
//带权周转时间
};
fcfsa[100];
//结构体数组
函数说明
voidFinput（fcfs*p,intN）;
//输入函数，初始化
voidFsort（fcfs*p,intN）;
//按到达时间排序，先到达排在前面
voidFsort2（fcfs*p,intN）;
//按进程大小排序，先到达排在前面
voidF_method（fcfs*p,intN）//先来先服务算法
voidF_method2（fcfs*p,intN）//短作业优先程序
voidSJF（fcfs*p,intN）；
//短作业优先
voidFCFS（fcfs*p,intN）;
//先来先服务
voidSJF（fcfs*p,intN）//短作业优先
voidFPrint（fcfs*p,intN）//输出函数
求完成时间算法
1）FCFS算法流程图
2）SJF算法流程图
l程序
#include<
stdio.h>
floatarrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0;
//定义先来先服务算法进程的最大数量
voidFinput（fcfs*p,intN）//输入函数
inti;
printf（"
输入进程的名称、到达时间、服务时间:
（例如:
x0100）\n"
）;
for（i=0;
i<
=N-1;
i++）
{
printf（"
输入第%d进程的名称、到达时间、服务时间:
\n"
i+1）;
scanf（"
%s%f%f"
&
p[i].name,&
p[i].arrivetime,&
p[i].servicetime）;
}
}
//输出函数
voidFPrint（fcfs*p,intN）//输出函数
intk;
\n执行顺序:
%s"
p[0].name）;
for（k=1;
k<
N;
k++）
-%s"
p[k].name）;
\n进程名\t到达时间\t服务时间\t开始时间\t结束时间\t周转时间\t带权周转时间\n\n"
for（k=0;
%s\t%-.2f\t\t%-.2f\t\t%-.2f\t\t%-.2f\t\t%-.2f\t\t%-.2f\t\t\n\n"
p[k].name,p[k].arrivetime,p[k].servicetime,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].dqzztime）;
voidFsort（fcfs*p,intN）//按到达时间排序，先到达排在前面
for（inti=0;
for（intj=0;
j<
=i;
j++）
if（p[i].arrivetime<
p[j].arrivetime）//进行排序，如果先到达就排在前面
{
fcfstemp;
temp=p[i];
p[i]=p[j];
p[j]=temp;
}
}//运行结果
voidF_method（fcfs*p,intN）
if（k==0）
{
p[k].starttime=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].starttime+p[k].servicetime;
//结束时间=开始时间加上+现在进程的服务时间
k++）//求每个进程的信息
p[k].zztime=p[k].finishtime-p[k].arrivetime;
//周转时间=完成时间-到达时间
p[k].dqzztime=p[k].zztime/p[k].servicetime;
//带权周转时间=周转时间/服务时间
voidF_method2（fcfs*p,intN）//短作业优先核心程序
intnum;
intarrive=65535;
//寻找最早到达的进程
intmin_serive=65535;
//寻找最小服务时间进程
fcfsb[100];
//新建一个，进行排序
intstate[100];
//设置100个标志位
for（i=0;
state[i]=0;
if（p[i].arrivetime<
arrive）
{arrive=p[i].arrivetime;
num=i;
b[0]=p[num];
state[num]=1;
b[0].finishtime=b[0].arrivetime+b[0].servicetime;
intj=0;
for（intk=1;
{min_serive=65535;
for（i=0;
{if（state[i]==1||p[i].arrivetime>
b[j].finishtime）//如果遇到已排序或者未到达的进程跳过
continue;
elseif（p[i].servicetime<
min_serive）
min_serive=p[i].servicetime;
num=i;
state[num]=1;
//找到合适的进程并赋值到B
b[++j]=p[num];
b[j].starttime=b[j-1].finishtime;
b[j].finishtime=b[j-1].finishtime+b[j].servicetime;
for（j=0;
j++）//求每个进程的信息
b[j].zztime=b[j].finishtime-b[j].arrivetime;
b[j].dqzztime=b[j].zztime/b[j].servicetime;
p[j]=b[j];
//先来先服务
voidFCFS（fcfs*p,intN）
Fsort（p,N）;
//对每个进程排序
F_method（p,N）;
FPrint（p,N）;
voidSJF（fcfs*p,intN）
F_method2（p,N）;
intmain（）//主函数
intN;
输入进程数:
"
scanf（"
%d"
N）;
Finput（a,N）;
先来先服务\n"
FCFS（a,N）;
\n\n\n"
短作业优先\n"
SJF（a,N）;
return0;
【小结或讨论】
1.能实现的功能输入进程个数Num，每个进程到达时间ArrivalTime[i]，服务时间ServiceTime[i]。
采用先来先服务FCFS或者短作业优先SJF进程调度算法进行调度，计算每个进程的完成时间、周转时间和带权周转时间，并且统计Num个进程的平均周转时间和平均带权周转时间。
2、FCFS算法相对于SJF算法来说，比较简单，在FCFS算法中，主要用到的是队列，按照作业的到达时间来进行排序排序算法。
3、SJF算法中就需要考虑到很多的因素，因为0时刻到达的作业肯定第一个执行，然后再考虑剩余的作业的服务时间以决定哪一个作业先执行，但是这是在确保所有剩余的作业都处于就绪状态的情况下。
如若不然，还要考虑每一个作业执行完后，有哪些作业进入了排队状态。
4、SJF算法中还要考虑到如若同一时刻进入了多个作业，还要将这若干个作业按照服务时间进行排序，再考虑执行情况。
5、无论是FCFS还是SJF算法，关键都是求完成时间。
FCFS算法执行进程的顺序是由到达时间的先后决定的，SJF算法的顺序是由服务时间决定的。
6、SJF求完成时间时，应当注意如下情况：
A进程完成完成后，依据服务时间，轮到B执行,而A的完成时间<
B的到达之间，也就是说A完成时，B尚未到达，这种情况下，B的完成时间=B的到达时间+B的服务时间。
7、通过本次实验，我对于作业调度的机制，有了进一步的认识，对于相同的作业，不同的调度顺序，会使周转时间以及赋权周转时间产生变化。
8、先到先服务算法虽然算法实现较为简便，但是效率上存在一定的问题。
短作业优先算法可以大大提高效率方面的问题，但是实现起来较为复杂。
升级会员 