> 问题详情
若每个作业对应一个进程，为了照顾紧急作业的用户应采用（20)。A．时间片轮转法B．短作业优先调度算法
悬赏：0&答案豆
提问人：匿名网友
发布时间：
若每个作业对应一个进程，为了照顾紧急作业的用户应采用(20)。A．时间片轮转法B．短作业优先调度算法C．先来先服务调度算法(FCFS)D．基于优先权的剥夺调度算法请帮忙给出正确答案和分析，谢谢！
权威推荐： & &
为您推荐的考试题库
网友回答（共1条）
匿名网友&&&&lv1&&&&提问收益：0.00&答案豆
您可能感兴趣的试题
1操作系统内核与用户程序、应用程序之间的接口是(21)。A．键盘B．I/O设备C．shell命令D．服务器2若某虚拟存储器的用户编程空间有16页，每页为1KB，内存为4KB。某时刻一用户页表内调入内存的页面页号和物理块号对照如下：则逻辑地址0B27(H)所对应的物理地址是(24)，其中H表示十六进制数。A．0527(H)B．0B27(H)C．1227(H)D．0B32(H)3若一棵树中有度数为1至m的各种结点数分别为n1，n2，n3，…，nm，则该树中叶结点的个数为(27)。A．B．C．D．4通常所说的I/O设备指的是(28)。A．通信设备B．控制设备C．文件传输设备D．输入输出设备
我有更好的答案
请先输入下方的验证码查看最佳答案
图形验证：
验证码提交中……
享三项特权
享三项特权
享三项特权
选择支付方式：
支付宝付款
郑重提醒：支付后，系统自动为您完成注册
请使用微信扫码支付(元)
支付后，系统自动为您完成注册
遇到问题请联系在线客服QQ：
请您不要关闭此页面,支付完成后点击支付完成按钮
遇到问题请联系在线客服QQ：
恭喜您！升级VIP会员成功
常用邮箱：
用于找回密码
确认密码：短作业优先调度算法
短作业优先调度算法
范文一：短作业（进程）优先调度算法：短作业调度算法是从后备队列中选择一个或者若干个估计运行时间最短的作业，将他们调入内存运行。而短进程优先调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或者发生某事件而被阻塞放弃处理机时再重新调度。短进程优先调度源代码：#include "stdio.h"struct sjf{char name[10];};sjf a[100];void input(sjf *p,int N){printf("intput the process's name & arrivetime & servicetime:\nfor exmple: a 0 100\n"); for(i=0;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){printf("run order:");printf("%s",p[0].name);for(k=1;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{ printf("%s\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t\n",p[k].name,p[k].arrivetime,p[k].servicetime,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].dqzztime);}}//排序void sort(sjf *p,int N){for(int i=0;ifor(int j=0;jif(p[i].arrivetime{temp=p[i];p[i]=p[j];p[j]=}}//运行阶段void deal(sjf *p, float arrivetime,float servicetime,float starttime,float finishtime,float &zztime,float &dqzztime,int N){for(k=0;k{if(k==0){p[k].starttime=p[k].p[k].finishtime=p[k].arrivetime+p[k].}else{p[k].starttime=p[k-1].p[k].finishtime=p[k-1].finishtime+p[k].}}for(k=0;k{p[k].zztime=p[k].finishtime-p[k].p[k].dqzztime=p[k].zztime/p[k].}}void sjff(sjf *p,int N){float arrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0;//对结构进行初始化sort(p,N);for(int m=0;m{if(m==0)p[m].finishtime=p[m].arrivetime+p[m].elsep[m].finishtime=p[m-1].finishtime+p[m].int i=0;for(int n=m+1;n{if(p[n].arrivetime}float min=p[m+1].int next=m+1;//m+1=nfor(int k=m+1;k{if(p[k+1].servicetime{min=p[k+1].next=k+1;}}temp=p[m+1];p[m+1]=p[next];p[next]=}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 "stdio.h"struct sjf{char name[10];};sjf a[100];void input(sjf *p,int N){printf("intput the process's name & arrivetime & servicetime:\nfor exmple: a 0 100\n"); for(i=0;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){printf("run order:");printf("%s",p[0].name);for(k=1;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{ printf("%s\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t\n",p[k].name,p[k].arrivetime,p[k].servicetime,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].dqzztime);}}//排序void sort(sjf *p,int N){for(int i=0;ifor(int j=0;jif(p[i].arrivetime{temp=p[i];p[i]=p[j];p[j]=}}//运行阶段void deal(sjf *p, float arrivetime,float servicetime,float starttime,float finishtime,float &zztime,float &dqzztime,int N){for(k=0;k{if(k==0){p[k].starttime=p[k].p[k].finishtime=p[k].arrivetime+p[k].}else{p[k].starttime=p[k-1].p[k].finishtime=p[k-1].finishtime+p[k].}}for(k=0;k{p[k].zztime=p[k].finishtime-p[k].p[k].dqzztime=p[k].zztime/p[k].}}void sjff(sjf *p,int N){float arrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0;//对结构进行初始化sort(p,N);for(int m=0;m{if(m==0)p[m].finishtime=p[m].arrivetime+p[m].elsep[m].finishtime=p[m-1].finishtime+p[m].int i=0;for(int n=m+1;n{if(p[n].arrivetime}float min=p[m+1].int next=m+1;//m+1=nfor(int k=m+1;k{if(p[k+1].servicetime{min=p[k+1].next=k+1;}}temp=p[m+1];p[m+1]=p[next];p[next]=}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);}
范文二：操作系统课程设计短作业优先调度算法学
学 生 姓 名
指导教师姓名目
录一、实验课题.....................................................................................二、课程设计的目的..........................................................................三、设计内容.....................................................................................四、设计要求.....................................................................................五、主要数据结构及其说明...............................................................六、程序运行结果............................................................................七、源程序文件.................................................................................八、实验体会.....................................................................................九、参看文献.....................................................................................实验题目采用短作业优先算法的进程调度程序课程设计的目的? 操作系统课程设计是计算机专业重要的教学环节，它为学生提供了一个既动手又动脑，将课本上的理论知识和实际有机的结合一起，独立分析和解决实际问题的机会。? 进一步巩固和复习操作系统的基础知识。? 培养学生结构化程序、模块化程序设计的方法和能力。 ? 提高学生调试程序的技巧和软件设计的能力。? 提高学生分析问题、解决问题以及综合利用C语言进行程序设计的能力。设计内容设计并实现一个采用短作业优先算的进程调度算法演示程序设计要求1.
每一个进程有一个PCB，其内容可以根据具体情况设定。2.
进程数、进入内存时间、要求服务时间、优先级等均可以在界面上设定
可读取样例数据（要求存放在外部文件中）进行进程数、进入内存时间、时间片长度、进程优先级的初始化4.
可以在运行中显示各进程的状态：就绪、执行 （由于不要求设置互斥资源与进程间同步关系，故只有两种状态）
具有一定的数据容错性主要数据结构及其说明算法的简要说明：短作业（进程）优先调度算法SJ（P）F，是指对短作业或短进程优先调度的算法。它们可以分别用于作业调度和进程调度。短作业优先（SJF）的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。而短进程（SPF）调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机再重新调度。优点是SJ(P)F调度算法能有效地降低作业（进程）的平均等待时间，提高系统吞吐量。缺点是该算法对长作业不利；完全未考虑作业的紧迫程度，因而不能保证紧迫性作业（进程）长期不被调度；由于作业（进程）的长短只是根据用户所提供的估计执行时间而定的，而用户又可能会有意或无意地缩短其作业的估计运行时间，致使该算法不一定能真正做到短作业游戏那调度。该程序定义了一个进程数据块(struct spf)，该数据块有进程名(name)、到达时间(arrivetime)、服务时间(servicetime)、开始执行时间(starttime)、完成时间(finishtime)、周转时间(zztime)、平均周转时间(averzztime)。用到的公式有：完成时间=到达时间+服务时间；周转时间=完成时间-到达时间；(第一次执行的进程的完成时间=该进程的到达时间；下一个进程的开始执行时间=上一个进程的完成时间)。运行进程的顺序需要对进程的到达时间和服务时间进行比较。如果某一进程是从0时刻到达的，那么首先执行该进程；之后就比较进程的服务时间，谁的服务时间短就先执行谁（如果服务时间相同则看它们的到达时间，到达时间短的先执行）；如果到达时间和服务时间相同，则按先来先服务算法执行。程序运行结果1 进入操作界面如下2输入进程的数目3输入进程的信息4 运行顺序流程图源程序文件#include
#include#define MAX 100
//最多能管理的作业数目
struct jcb
//作业控制块JCB,定义为结构体
{char name[10];
//作业名 //作业到达时间
//作业服务时间
//作业开始执行时间
//作业完成时间
//作业周转时间
//作业平均周转时间
};jcb a[MAX];void input(jcb *p,int N){printf("***************************************\n");
for(i=0;i{system("pause"); system("cls");printf("please input the process of %d th:\n",i+1);
printf("please input the name:\n");scanf("%s",&p[i].name);printf("please input the ArrvialTime:\n");
scanf("%f",&p[i].arrivetime);printf("please input the ServiceTime:\n");scanf("%f",&p[i].servicetime);printf("\n");
arrivetime,float finishtime,float zztime,float avezztime,int N)
{printf("调度顺序:");
printf("%s",p[0].name);
for(k=1;kprintf("-->%s",p[k].name);servicetime,float starttime,float}printf("\n\n");printf("\t\t\t作业信息:\n");printf("\nname\tarrive\tservice\tstart\tfinish\tzz\tavezz\n");for(k=0;kprintf("%s\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t\n",p[k].name,p[k].arrivetime,p[k].servicetime,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].avezztime);
}void sort(jcb *p,int N)
{for(int i=0;ifor(int j=0;jif(p[i].arrivetime{
temp=p[i];p[i]=p[j];
arrivetime,float
servicetime,float starttime,float finishtime,float &zztime,float &avezztime,int N){for(k=0;k{if(k==0){p[k].starttime=p[k].p[k].finishtime=p[k].arrivetime+p[k].}else{p[k].starttime=p[k-1].p[k].finishtime=p[k-1].finishtime+p[k].}}for(k=0;k{p[k].zztime=p[k].finishtime-p[k].p[k].avezztime=p[k].zztime/p[k].
}}void jcbf(jcb *p,int N){float
arrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,avezztime=0;
sort(p,N);for(int m=0;m{if(m==0)p[m].finishtime=p[m].arrivetime+p[m].elsep[m].finishtime=p[m-1].finishtime+p[m].int i=0;for(int n=m+1;n{if(p[n].arrivetimei++;}float min=p[m+1].int next=m+1;//m+1=nfor(int k=m+1;k{if(p[k+1].servicetime{min=p[k+1].next=k+1;}}temp=p[m+1];p[m+1]=p[next];p[next]=}
deal(p,arrivetime,servicetime,starttime,finishtime,zztime,avezztime,N);
Print(p,arrivetime,servicetime,starttime,finishtime,zztime,avezztime,N);
}int main(){system("color 2f"); printf("\n\t********************\n"); printf("\t1.短作业优先\n\n"); printf("\t0.退出\n\t");printf("\n\t********************\n"); scanf("%d",&p); switch(p) { case 0:
printf("运行结束。\n"); exit(0); case 1:while(1){
system("cls");
system("color 1f");
printf("\t\t\t------短作业优先调度算法------\n");printf("请输入作业数目:");scanf("%d",&N);if(N>MAX) {
printf("\t!!输入的作业数目太大,请输入不大于%d的整数\n",MAX);printf("按Q或者q退出程序,按其他任意键继续测试...");ch = getch();if(ch=='Q'||ch=='q'){
input(a,N);jcb *b=a;jcbf(b,N);printf("按Q或者q退出程序,按其他任意键继续测试...");ch = getch();if(ch=='Q'||ch=='q'){}}return 0;}}实验体会通过本次课程设计对用短作业的优先调度算法有了更深入的理解和掌握，进一步巩固和复习操作系统的基础知识，更进一步的了解了结构化模块化程序设计的方法，提高了调试程序的技巧，提高了自己的动手能力。通过模拟进程的调度问题，将课本上的理论知识和实际有机的结合起来，独立分析和解决实际问题。更加深了我对于操作系统理论的理解，在自己的动手操作过程中，让自己多多的在实践中可以加深对理论的理解。实验课上，我们按照老师的要求，把完成的模块组合到主程序上。组合简单，但是要让各个部分没有分歧地融为一体，却是很难。往往组合之后会有很多错误的地方，我们要一个一个地去解决。有些错误很容易修正，但有些却是绞尽脑汁都弄不明白的。比如说，有个显示的模块，程序写的是对的，但不知道为什么，总是出错。改了许多次，后来才行。我们应该在错误中修正自己的错误，在失败中为成功积累经验。小组是一个集体，我们个人在集体中应该发挥各自的长处，为集体奉献自己的力量，让小组发挥出最大的能量。.参考文献1）宗大华，宗涛，陈吉人著
北京：人民邮电出版社，20092）宋晓宇 ， windows操作系统核心编程实验教程
中国铁道出版社3）张丽芬 刘利雄 王金玉编著
操作系统实验教程
清华大学出版社
范文三：短作业优先调度算法学
计算机科学与技术
学 生 姓 名
指导教师姓名目录一、 实验题目............................................................................................................二、 课程设计的目的................................................................................................三、 设计内容............................................................................................................四、 设计要求............................................................................................................五、 主要数据结构及其说明....................................................................................六、 程序运行结果....................................................................................................七、 源程序文件........................................................................................................八、 实验体会............................................................................................................
参考文献………………………………………………………………………………………………………实验题目采用短作业优先算法的进程调度程序课程设计的目的? 操作系统课程设计是计算机专业重要的教学环节，它为学生提供了一个既动手又动脑，将课本上的理论知识和实际有机的结合一起，独立分析和解决实际问题的机会。? 进一步巩固和复习操作系统的基础知识。? 培养学生结构化程序、模块化程序设计的方法和能力。 ? 提高学生调试程序的技巧和软件设计的能力。? 提高学生分析问题、解决问题以及综合利用C语言进行程序设计的能力。设计内容设计并实现一个采用短作业优先算的进程调度算法演示程序设计要求1.
每一个进程有一个PCB，其内容可以根据具体情况设定。2.
进程数、进入内存时间、要求服务时间、优先级等均可以在界面上设定3.
可读取样例数据（要求存放在外部文件中）进行进程数、进入内存时间、时间片长度、进程优先级的初始化4.
可以在运行中显示各进程的状态：就绪、执行 （由于不要求设置互斥资源与进程间同步关系，故只有两种状态）5.
具有一定的数据容错性主要数据结构及其说明算法的简要说明：短作业（进程）优先调度算法SJ（P）F，是指对短作业或短进程优先调度的算法。它们可以分别用于作业调度和进程调度。短作业优先（SJF）的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。而短进程（SPF）调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机再重新调度。优点是SJ(P)F调度算法能有效地降低作业（进程）的平均等待时间，提高系统吞吐量。缺点是该算法对长作业不利；完全未考虑作业的紧迫程度，因而不能保证紧迫性作业（进程）长期不被调度；由于作业（进程）的长短只是根据用户所提供的估计执行时间而定的，而用户又可能会有意或无意地缩短其作业的估计运行时间，致使该算法不一定能真正做到短作业游戏那调度。该程序定义了一个进程数据块(struct spf)，该数据块有进程名(name)、到达时间(arrivetime)、服务时间(servicetime)、开始执行时间(starttime)、完成时间(finishtime)、周转时间(zztime)、带权周转时间(dqzztime)。用到的公式有：完成时间=到达时间+服务时间；周转时间=完成时间-到达时间；带权周转时间=周转时间/服务时间；(第一次执行的进程的完成时间=该进程的到达时间；下一个进程的开始执行时间=上一个进程的完成时间)。运行进程的顺序需要对进程的到达时间和服务时间进行比较。如果某一进程是从0时刻到达的，那么首先执行该进程；之后就比较进程的服务时间，谁的服务时间短就先执行谁（如果服务时间相同则看它们的到达时间，到达时间短的先执行）；如果到达时间和服务时间相同，则按先来先服务算法执行。程序运行结果1 进入操作界面如下2输入进程的数目3输入进程的信息4 运行顺序流程图源程序文件#include
#include#define MAX 100
//最多能管理的作业数目
struct jcb
//作业控制块JCB,定义为结构体
{char name[10];
//作业到达时间
//作业服务时间
//作业开始执行时间
//作业完成时间
//作业周转时间
//作业平均周转时间
};jcb a[MAX];void input(jcb *p,int N)
{printf("请分别输入:\n\t作业名,到达时间,服务时间(如:JOB1 5 10)\n\n");
for(i=0;i{printf("请输入第%d个作业信息:",i+1);scanf("%s%f%f",&p[i].name,&p[i].arrivetime,&p[i].servicetime);
printf("\n");
arrivetime,float
servicetime,float zztime,float avezztime,int N)
{printf("调度顺序:");
printf("%s",p[0].name);
for(k=1;kprintf("-->%s",p[k].name);
printf("\n\n");printf("\t\t\t作业信息:\n");printf("\nname\tarrive\tservice\tstart\tfinish\tzz\tavezz\n");
for(k=0;kstarttime,float finishtime,floatprintf("%s\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t\n",p[k].name,p[k].arrivetime,p[k].servicetime,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].avezztime);
}void sort(jcb *p,int N)
{for(int i=0;i
temp=p[i];p[i]=p[j];
arrivetime, float
servicetime, float starttime, float finishtime, float &zztime, float &avezztime,int N){for(k=0;kp[k].starttime=p[k].p[k].finishtime=p[k].arrivetime+p[k].}
{p[k].starttime=p[k-1].p[k].finishtime=p[k-1].finishtime+p[k].}}for(k=0;k{p[k].zztime=p[k].finishtime-p[k].
}p[k].avezztime=p[k].zztime/p[k].void jcbf(jcb *p,int N){float
arrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,avezztime=0;
sort(p,N);for(int m=0;m{if(m==0)p[m].finishtime=p[m].arrivetime+p[m].elsep[m].finishtime=p[m-1].finishtime+p[m].int i=0;for(int n=m+1;n{if(p[n].arrivetimei++;}float min=p[m+1].int next=m+1;//m+1=nfor(int k=m+1;k{if(p[k+1].servicetime{min=p[k+1].next=k+1;}}temp=p[m+1];p[m+1]=p[next];p[next]=}deal(p,arrivetime,servicetime,starttime,finishtime,zztime,avezztime,N);Print(p,arrivetime,servicetime,starttime,finishtime,zztime,avezztime,N); }int main() {while(1){system("CLS");
printf("\t\t\t*********短作业优先调度算法*********\n");printf("请输入作业数目:");scanf("%d",&N);
if(N>MAX){printf("\t!!输入的作业数目太大,请输入不大于%d的整数\n",MAX);
printf("按Q或者q退出程序,按其他任意键继续测试...");ch = getch();if(ch=='Q'||ch=='q'){}}
input(a,N);
jcbf(b,N);printf("按Q或者q退出程序,按其他任意键继续测试...");ch = getch();if(ch=='Q'||ch=='q'){}}return 0;}体会心得每一次课程设计度让我学到了在平时课堂不可能学到的东西。所以我对每一次课程设计的机会都非常珍惜。不一定我的课程设计能够完成得有多么完美，但是我总是很投入的去研究去学习。整个课程设计下来，我浏览的相关网页已经超过了100个（不完全统计）。当然网上的东西很乱很杂，自己要能够学会筛选。不能决定对或错的，有个很简单的方法就是去尝试。同学间的讨论，这是很重要的。老师毕竟比较忙。对于课程设计最大的讨论伴侣应该是同学了。大家都在研究同样的问题，讨论起来，更能够把思路理清楚，相互帮助，可以大大提高效率。最好在做课设的过程中能够有记录的习惯，这样在写实验报告时能够比较完整的回忆起中间遇到的各种问题。对于本次课设的题目，SJF算法以进入系统的作业所要求的CPU时间为标准，总选取估计计算时间最短的作业投入运行。SJF由于考虑到作业的服务时间，只在某种程度上效率要高，但大多数上即使算法易于实现，效率也不高，主要弱点是忽视了作业等待时间，会出现饥饿现象。参考文献1）宗大华，宗涛，陈吉人著《操作系统》北京：人民邮电出版社，20092）李爱华，程磊著《面相对象程序设计（C++语言）》北京: 清华大学出版社，20103）宋晓宇《windows操作系统核心编程实验教程》中国铁道出版社4）张丽芬，刘利雄，王金玉编著《操作系统实验教程>清华大学出版社
范文四：先来先服务调度算法和短作业优先调度算法#includestruct fcfs
//定义进程的结构体{char name[10];
//到达时间
//服务时间
//开始时间
//完成时间
//周转时间
//带权周转时间};struct sjf
//定义进程的结构体{char name[10];
//到达时间
//服务时间
//开始时间
//完成时间
//周转时间
//带权周转时间};fcfs a[100]; //定义先来先服务算法进程的最大数量sjf b[100];
//定义短作业优先算法进程的最大数量void Finput(fcfs *p,int N)
//输入函数{printf("intput the process's name & arrivetime & servicetime:\nfor exmple: a 0 100\n");
for(i=0;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 FPrint(fcfs *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float dqzztime,int N){printf("\nrun order:\n");printf("%s",p[0].name);for(k=1;k{printf("-->%s",p[k].name);}printf("\n\nthe process's information:\n");printf("\nname\tarrive\tservice\tstart\tfinish\tzz\tdqzz\n\n");for(k=0;k{printf("%s\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t\n\n",p[k].name,p[k].arrivetime,p[k].servicetime,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].dqzztime);}}void Fsort(fcfs *p,int N)
//按到达时间排序，先到达排在前面{for(int i=0;ifor(int j=0;jif(p[i].arrivetime{temp=p[i];p[i]=p[j];p[j]=}}//运行结果void Fdeal(fcfs *p, float arrivetime,float servicetime,float starttime,float finishtime,float &zztime,float &dqzztime,int N){for(k=0;k{if(k==0){p[k].starttime=p[k].p[k].finishtime=p[k].arrivetime+p[k].}else{p[k].starttime=p[k-1].
//开始时间=前一个进程的完成时间
p[k].finishtime=p[k-1].finishtime+p[k].
//结束时间=前一个进程的完成时间+现在进程的服务时间}}for(k=0;k{p[k].zztime=p[k].finishtime-p[k].
//周转时间=完成时间-到达时间
p[k].dqzztime=p[k].zztime/p[k].
//带权周转时间=周转时间/服务时间
}}//先来先服务void FCFS(fcfs *p,int N){float arrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0;
Fsort(p,N);Fdeal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);FPrint(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);}void Sinput(sjf *p,int N)
//输入函数{printf("intput the process's name & arrivetime & servicetime:\nfor exmple: a 0 100\n\n");
for(i=0;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 SPrint(sjf *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float dqzztime,int N){printf("\nrun order:\n");printf("%s",p[0].name);for(k=1;k{printf("-->%s",p[k].name);}printf("\n\nthe process's information:\n");printf("\nname\tarrive\tservice\tstart\tfinish\tzz\tdqzz\n");for(k=0;k{printf("%s\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t\n\n",p[k].name,p[k].arrivetime,p[k].servicetime,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].dqzztime);}}void Ssort(sjf *p,int N)
//按短作业优先算法排序{for(int i=1;ifor(int j=1;jif(p[i].servicetime{temp=p[i];p[i]=p[j];p[j]=}}//运行结果void Sdeal(sjf *p, float arrivetime,float servicetime,float starttime,float finishtime,float &zztime,float &dqzztime,int N)for(k=0;k{if(k==0){p[k].starttime=p[k].p[k].finishtime=p[k].arrivetime+p[k].}else{p[k].starttime=p[k-1].
//开始时间=前一个进程的完成时间
p[k].finishtime=p[k-1].finishtime+p[k].
//结束时间=前一个进程的完成时间+现在进程的服务时间}}for(k=0;k{p[k].zztime=p[k].finishtime-p[k].
//周转时间=完成时间-到达时间
p[k].dqzztime=p[k].zztime/p[k].
//带权周转时间=周转时间/服务时间
}}void SJF(sjf *p,int N){float arrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0;
Ssort(p,N);Sdeal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);SPrint(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);}void main()
//主函数{while(1){printf("选择哪种算法？1、先来先服务算法（FCFS） 2、段作业优先算法（SJF）\n");
scanf("%d",&n);}
//先来先服务算法（FCFS） {
printf("------先来先服务调度算法------\n");
printf("input the process's number:\n");
scanf("%d",&N);
Finput(a,N);
FCFS(a,N); }
//短作业优先算法（SJF） {
printf("------短作业优先调度算法------\n");
printf("input the process's number:\n");
scanf("%d",&M);
Sinput(b,M);
} printf("继续工作吗？(Y/N):"); scanf("%s",&o); if(o=='Y') if(o=='N') }
范文五：《操作系统》实验一实验报告【实验题目】：先来先服务FCFS和短作业优先SJF进程调度算法【实验目的】通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。【实验内容】问题描述：设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。假设有n个进程分别在T1, … ,Tn时刻到达系统，它们需要的服务时间分别为S1, … ,Sn。分别采用先来先服务FCFS和短作业优先SJF进程调度算法进行调度，计算每个进程的完成时间，周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。 程序要求如下：1）进程个数n；每个进程的到达时间T1, … ,Tn和服务时间S1, … ,Sn；选择算法1-FCFS，2-SJF。2）要求采用先来先服务FCFS和短作业优先SJF分别调度进程运行，计算每个进程的周转时间，带权周转时间，并且计算所有进程的平均周转时间，带权平均周转时间；3）输出：要求模拟整个调度过程，输出每个时刻的进程运行状态，如“时刻3：进程B开始运行”等等；4）输出：要求输出计算出来的每个进程的周转时间，带权周转时间，所有进程的平均周转时间，带权平均周转时间。【实验过程】#include#define MaxNum 100int
ArrivalTime[MaxNum];double
ServiceTime[MaxNum];double
FinishTime[MaxNum];double
WholeTime[MaxNum];double
AVEWholeTime[MaxNum];double
AVEWeightWholeTime[MaxNum];double
WeightWholeTime[MaxNum];double AverageWT_FCFS,AverageWT_SJF;double AverageWWT_FCFS,AverageWWT_SJF;double AllTime,WeightAllTdouble a[MaxNum];int b[MaxNum];int c[MaxNum];int d[MaxNum];void FCFS();void SJF();void FCFS(){int ProcessN cout>ProcessN cout>ServiceTime[i]; //cout>ArrivalTime[i]; //cout{
} for(int i=0;i} cout} for(int i=0;icout}
} //coutvoid SJF(){int ProcessN cout>ProcessN cout>ArrivalTime[i]; //cout{
} couta[j]) {
} exchange=a[i]; a[i]=a[j]; a[j]= a[i]=ServiceTime[i]; cin>>ServiceTime[i]; //coutFinishTime[0]=ServiceTime[0]; for(int i=1;i} if(FinishTime[b[i-1]]} cout}coutcoutfor(int i=0;icoutcoutfor(int i=0;iAVEWholeTime[i]=WholeTime[i]; //coutWholeTime[i]=FinishTime[i]-ArrivalTime[i]; cout//cout}//coutAverageWT_SJF=AllTime/ProcessNcoutfor(int i=0;icoutcoutAVEWeightWholeTime[i]=WeightWholeTime[i]; coutWeightWholeTime[i]=WholeTime[i]/ServiceTime[i];}for(int i=0;iAVEWeightWholeTime[i+1]=AVEWeightWholeTime[i]+AVEWeightWholeTime[i+1];
}void main() {char flag='Y';coutcoutcoutAverageWWT_SJF=WeightAllTime/ProcessN coutcoutcoutcin>>n;switch(n)
case'1':FCFS();case'2':
SJF();default:
coutcout}coutcout>}} 'Y'or'y'钮继续,按【实验结果】
先来先服务算法短作业优先算法#include #define MaxNum 100int
ArrivalTime[MaxNum]; double
ServiceTime[MaxNum]; double
FinishTime[MaxNum]; double
WholeTime[MaxNum]; double
AVEWholeTime[MaxNum];double
AVEWeightWholeTime[MaxNum]; double
WeightWholeTime[MaxNum];double AverageWT_FCFS,AverageWT_SJF;
double AverageWWT_FCFS,AverageWWT_SJF; double AllTime,WeightAllT double a[MaxNum]; int b[MaxNum]; int c[MaxNum]; int d[MaxNum]; void FCFS(); void SJF();void FCFS() {ProcessN--先来先服务算法----------");入进程个数：");",&ProcessNum);进程到达时间：");i=0;i&ArrivalTime[i]);入进程服务时间：";cessNi++)Time[i];cessNi++)=ServiceTime[i];cessNi++)1]=FinishTime[i]+FinishTime[i+1];printf("--------printf("请输scanf("%d printf("输入printf("\n"); for(int {scanf("%d "
}printf("\n"); coutcin>>Service
}printf("\n"); for( i=0;iFinishTime[i]}for( i=0;iFinishTime[i+cessNum-1;i++)"完成时间：";cessNi++)Time[i]周转时间：";cessNi++)=FinishTime[i]-ArrivalTime[i];cessNi++)Time[i]平均周转时间：";cessNi++)me[i]=WholeTime[i];for( i=0;icoutcoutcoutprintf("\n"); coutWholeTime[i]}for( i=0;icoutprintf("\n"); coutAVEWholeTi }cessNi++)me[i+1]=AVEWholeTime[i]+AVEWholeTime[i+1];EWholeTime[i+1];eFCFS=AllTime/ProcessN周转时间"带权周转时间：";cessNi++)Time[i]=WholeTime[i]/ServiceTime[i];cessNi++)WholeTime[i]平均带权周转时间：";cessNi++)holeTime[i]=WeightWholeTime[i];{AVEWholeTiAllTime=AV}coutWeightWhole}for( i=0;icoutprintf("\n"); coutAVEWeightWcessNi++)holeTime[i+1]=AVEWeightWholeTime[i]+AVEWeightWholeTime[i+1];e=AVEWeightWholeTime[i+1];_FCFS=WeightAllTime/ProcessN带权周转时间"void SJF() {ProcessN---短作业优先算法----------"入进程个数：";N进程到达时间：";i=0;iime[i];printf("\n");入进程服务时间：";cessNi++)for( i=0;iAVEWeightWWeightAllTim
}AverageWWTcoutintcout>Processcoutcin>>ArrivalT
}coutTime[i];cessNi++)me[i];cessNum-1;i++)//实现从第一位开始排序j=i+1;j=ServiceTime[0];cessNi++)//获取数组下标j=1;jcin>>Service }printf("\n"); for( i=0;ia[i]=ServiceTi}for( i=1;idouble
{if(a[i]>a[j])
{exchange=a[i]a[i]=a[j];a[j]=exchange
} }FinishTime[0]for( i=1;ifor(intceTime[j])cessNi++)[b[i-1]]me[b[i]];
];i]]=a[i];if(a[i]==Servi
} }for( i=1;iif(FinishTime {inttemp=b[i];b[i]=b[i+1];b[i+1]=
}a[i]=ServiceTia[i]=a[i-1]+a[iFinishTime[b[}for( i=0;icessNum-1;i++)"成时间：";cessNi++)Time[i]转时间：";cessNi++)=FinishTime[i]-ArrivalTime[i];cessNi++)Time[i]平均周转时间：";cessNi++)me[i]=WholeTime[i];cessNi++){coutcoutcoutprintf("\n"); coutWholeTime[i]}for( i=0;icoutprintf("\n"); coutAVEWholeTi }for( i=0;ime[i+1]=AVEWholeTime[i]+AVEWholeTime[i+1];EWholeTime[i+1];SJF=AllTime/ProcessN周转时间"权周转时间：";cessNi++)Time[i]=WholeTime[i]/ServiceTime[i];cessNi++)WholeTime[i]均带权周转时间：";cessNi++)holeTime[i]=WeightWholeTime[i];cessNi++)AVEWholeTiAllTime=AV}AverageWT_coutWeightWhole}for( i=0;icoutprintf("\n"); coutAVEWeightW }for( i=0;iholeTime[i+1]=AVEWeightWholeTime[i]+AVEWeightWholeTime[i+1];e=AVEWeightWholeTime[i+1];_SJF=WeightAllTime/ProcessN带权周转时间"void main() {---调度算法FCFS && SJF-----------"Y'||flag=='y')来先服务 FCFS 算法 ."作业优先 SJF 算法."请您选择算法的序号："您输出有误!"AVEWeightWWeightAllTim
}AverageWWTcoutchar flag='Y';coutcout>n;switch(n)
default:cout继续调度算法FCFS && SJF，按'Y'or'y'钮继续,按照'N'or'n'键退出"}printf("\n");
范文六：实
告学生姓名：
指导教师：一、实验室名称：二、实验项目名称：进程调度算法的设计三、实验原理：短作业（进程）优先调度算法：短作业调度算法是从后备队列中选择一个或者若干个估计运行时间最短的作业，将他们调入内存运行。而短进程优先调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或者发生某事件而被阻塞放弃处理机时再重新调度。时间片轮转法：系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的队尾；然后，再把处理机分配给就绪队列中的新的队首进程，同时也让它执行一个时间片。这样就可以保证就绪队列中的所有进程在一个给定的时间内均能获得一时间片的处理机执行时间。四、实验目的：通过对进程调度算法的设计，深入理解进程调度的原理五、实验内容：1．编写程序实现SJ（P）F算法2．编写程序实现RR算法六、实验器材（设备、元器件）：装有VC++6.0的PC机一台七、实验步骤：1．打开VC，设计编写程序的源代码2．编译运行程序的源代码3．分析检验程序的结果是否正确4．总结实验结果及结论短进程优先调度源代码：#include "stdio.h"struct sjf{char name[10];};sjf a[100];void input(sjf *p,int N){printf("intput the process's name & arrivetime & servicetime:\nfor exmple: a 0 100\n"); for(i=0;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){printf("run order:");printf("%s",p[0].name);for(k=1;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{ printf("%s\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t\n",p[k].name,p[k].arrivetime,p[k].servicetime,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].dqzztime);}}//排序void sort(sjf *p,int N){for(int i=0;ifor(int j=0;jif(p[i].arrivetime{temp=p[i];p[i]=p[j];p[j]=}}//运行阶段void deal(sjf *p, float arrivetime,float servicetime,float starttime,float finishtime,float &zztime,float &dqzztime,int N){for(k=0;k{if(k==0){p[k].starttime=p[k].p[k].finishtime=p[k].arrivetime+p[k].}else{p[k].starttime=p[k-1].p[k].finishtime=p[k-1].finishtime+p[k].}}for(k=0;k{p[k].zztime=p[k].finishtime-p[k].p[k].dqzztime=p[k].zztime/p[k].}}void sjff(sjf *p,int N){float arrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0;//对结构进行初始化sort(p,N);for(int m=0;m{if(m==0)p[m].finishtime=p[m].arrivetime+p[m].elsep[m].finishtime=p[m-1].finishtime+p[m].int i=0;for(int n=m+1;n{if(p[n].arrivetime}float min=p[m+1].int next=m+1;//m+1=nfor(int k=m+1;k{if(p[k+1].servicetime{min=p[k+1].next=k+1;}}temp=p[m+1];p[m+1]=p[next];p[next]=}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
//物理页数#defineprintf("|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|\n")typedef struct PCB{int ID;int ReachTint TotalT}PCB;
//进程号，到达时间和服务时间typedef struct NOTE //备份{ Myprintfint TotalT}NOTE;PCB A[M];
//5个进程PCB a[M];NOTEint queue[50]; //记录调度的进程int K=0; //调度进程数组的标识void INIT()//初始化{for(i=0;i{A[i].ID=-1;}}int GetNum()//计算进程数{int i,j=0;for(i=0;i{if(A[i].ID!=-1){j++;}}}int GetReach(int time)//找出到达进程号{for(i=0;i{if(a[i].ReachTime{a[i].ReachTime=100;}}return -1;}int GetInsert()//找出插入位置{for(i=0;i{if(A[i].ID==-1)}return -1;}void Forward(int num)//前移{for(i=0;i{A[i].ID=A[i+1].ID;A[i].TotalTime=A[i+1].TotalT}A[num-1].ID=-1;}void Process()//执行进程{queue[K]=A[0].ID;K++;A[0].TotalTime--;temp.ID=A[0].ID;temp.TotalTime=A[0].TotalT}void main(){int t=0;printf("RR算法\n\n");INIT();for(i=0;i{printf("请输入进程ID：");scanf("%d",&a[i].ID);printf("请输入到达时间：");scanf("%d",&a[i].ReachTime);printf("请输入服务时间：");scanf("%d",&a[i].TotalTime);} for(i=0;i}//进程数为0
Process();
Forward(num);
if(temp.TotalTime!=0)
A[num-1].ID=temp.ID;
A[num-1].TotalTime=temp.TotalT
} } printf("\n"); printf("调度顺序为：\n"); M for(i=0;i八、实验数据及结果分析：短作业优先调度算法的实验结果：时间片轮转调度算法结果：九、实验结论：本次实验成功的完成了短作业优先调度算法和轮转时间片调度算法的模拟，通过本次实验我们了解到短作业优先调度算法不利于长作业的处理，因为长作业将长期得不到处理，而轮转时间片调度算法则解决了这一问题。短长作业均能在每一个周期内分得一个时间片处理自己的任务。十、总结及心得体会：通过本次实验对短作业优先调度算法和时间片轮转调度算法有了更深入的理解，同时，对程序算法能力有了进一步的提高，同时对模块化编程有了更深入得理解，代码的模块化会使程序的代码复用率提高，提高编程的效率。十一、对本实验过程及方法、手段的改进建议：本次实验的时间片轮转调度算法由于教材版本不一样有两种结果，本次实验本人采取的新教材的版本，新版本的难度较老教材要大很多，实验时候可以根据具体情况选择一个适合自己的来做。报告评分：
指导教师签字：实
告学生姓名：
指导教师：一、实验室名称：二、实验项目名称：进程调度算法的设计三、实验原理：短作业（进程）优先调度算法：短作业调度算法是从后备队列中选择一个或者若干个估计运行时间最短的作业，将他们调入内存运行。而短进程优先调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或者发生某事件而被阻塞放弃处理机时再重新调度。时间片轮转法：系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的队尾；然后，再把处理机分配给就绪队列中的新的队首进程，同时也让它执行一个时间片。这样就可以保证就绪队列中的所有进程在一个给定的时间内均能获得一时间片的处理机执行时间。四、实验目的：通过对进程调度算法的设计，深入理解进程调度的原理五、实验内容：1．编写程序实现SJ（P）F算法2．编写程序实现RR算法六、实验器材（设备、元器件）：装有VC++6.0的PC机一台七、实验步骤：1．打开VC，设计编写程序的源代码2．编译运行程序的源代码3．分析检验程序的结果是否正确4．总结实验结果及结论短进程优先调度源代码：#include "stdio.h"struct sjf{char name[10];};sjf a[100];void input(sjf *p,int N){printf("intput the process's name & arrivetime & servicetime:\nfor exmple: a 0 100\n"); for(i=0;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){printf("run order:");printf("%s",p[0].name);for(k=1;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{ printf("%s\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t\n",p[k].name,p[k].arrivetime,p[k].servicetime,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].dqzztime);}}//排序void sort(sjf *p,int N){for(int i=0;ifor(int j=0;jif(p[i].arrivetime{temp=p[i];p[i]=p[j];p[j]=}}//运行阶段void deal(sjf *p, float arrivetime,float servicetime,float starttime,float finishtime,float &zztime,float &dqzztime,int N){for(k=0;k{if(k==0){p[k].starttime=p[k].p[k].finishtime=p[k].arrivetime+p[k].}else{p[k].starttime=p[k-1].p[k].finishtime=p[k-1].finishtime+p[k].}}for(k=0;k{p[k].zztime=p[k].finishtime-p[k].p[k].dqzztime=p[k].zztime/p[k].}}void sjff(sjf *p,int N){float arrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0;//对结构进行初始化sort(p,N);for(int m=0;m{if(m==0)p[m].finishtime=p[m].arrivetime+p[m].elsep[m].finishtime=p[m-1].finishtime+p[m].int i=0;for(int n=m+1;n{if(p[n].arrivetime}float min=p[m+1].int next=m+1;//m+1=nfor(int k=m+1;k{if(p[k+1].servicetime{min=p[k+1].next=k+1;}}temp=p[m+1];p[m+1]=p[next];p[next]=}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
//物理页数#defineprintf("|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|\n")typedef struct PCB{int ID;int ReachTint TotalT}PCB;
//进程号，到达时间和服务时间typedef struct NOTE //备份{ Myprintfint TotalT}NOTE;PCB A[M];
//5个进程PCB a[M];NOTEint queue[50]; //记录调度的进程int K=0; //调度进程数组的标识void INIT()//初始化{for(i=0;i{A[i].ID=-1;}}int GetNum()//计算进程数{int i,j=0;for(i=0;i{if(A[i].ID!=-1){j++;}}}int GetReach(int time)//找出到达进程号{for(i=0;i{if(a[i].ReachTime{a[i].ReachTime=100;}}return -1;}int GetInsert()//找出插入位置{for(i=0;i{if(A[i].ID==-1)}return -1;}void Forward(int num)//前移{for(i=0;i{A[i].ID=A[i+1].ID;A[i].TotalTime=A[i+1].TotalT}A[num-1].ID=-1;}void Process()//执行进程{queue[K]=A[0].ID;K++;A[0].TotalTime--;temp.ID=A[0].ID;temp.TotalTime=A[0].TotalT}void main(){int t=0;printf("RR算法\n\n");INIT();for(i=0;i{printf("请输入进程ID：");scanf("%d",&a[i].ID);printf("请输入到达时间：");scanf("%d",&a[i].ReachTime);printf("请输入服务时间：");scanf("%d",&a[i].TotalTime);} for(i=0;i}//进程数为0
Process();
Forward(num);
if(temp.TotalTime!=0)
A[num-1].ID=temp.ID;
A[num-1].TotalTime=temp.TotalT
} } printf("\n"); printf("调度顺序为：\n"); M for(i=0;i八、实验数据及结果分析：短作业优先调度算法的实验结果：时间片轮转调度算法结果：九、实验结论：本次实验成功的完成了短作业优先调度算法和轮转时间片调度算法的模拟，通过本次实验我们了解到短作业优先调度算法不利于长作业的处理，因为长作业将长期得不到处理，而轮转时间片调度算法则解决了这一问题。短长作业均能在每一个周期内分得一个时间片处理自己的任务。十、总结及心得体会：通过本次实验对短作业优先调度算法和时间片轮转调度算法有了更深入的理解，同时，对程序算法能力有了进一步的提高，同时对模块化编程有了更深入得理解，代码的模块化会使程序的代码复用率提高，提高编程的效率。十一、对本实验过程及方法、手段的改进建议：本次实验的时间片轮转调度算法由于教材版本不一样有两种结果，本次实验本人采取的新教材的版本，新版本的难度较老教材要大很多，实验时候可以根据具体情况选择一个适合自己的来做。报告评分：
指导教师签字：
范文七：电 子 科 技 大 学实
告学生姓名：胡钟文
指导教师：罗惠琼一、实验室名称： 主楼A2-412二、实验项目名称：进程调度算法的设计三、实验原理：短作业（进程）优先调度算法：短作业调度算法是从后备队列中选择一个或者若干个估计运行时间最短的作业，将他们调入内存运行。而短进程优先调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或者发生某事件而被阻塞放弃处理机时再重新调度。时间片轮转法：系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的队尾；然后，再把处理机分配给就绪队列中的新的队首进程，同时也让它执行一个时间片。这样就可以保证就绪队列中的所有进程在一个给定的时间内均能获得一时间片的处理机执行时间。四、实验目的：通过对进程调度算法的设计，深入理解进程调度的原理五、实验内容：1．编写程序实现SJ（P）F算法2．编写程序实现RR算法六、实验器材（设备、元器件）：装有VC++6.0的PC机一台七、实验步骤：1．打开VC，设计编写程序的源代码2．编译运行程序的源代码3．分析检验程序的结果是否正确4．总结实验结果及结论短进程优先调度源代码：#include "stdio.h"struct sjf{char name[10];};sjf a[100];void input(sjf *p,int N){printf("intput the process's name & arrivetime & servicetime:\nfor exmple: a 0 100\n"); for(i=0;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){printf("run order:");printf("%s",p[0].name);for(k=1;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{ printf("%s\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t\n",p[k].name,p[k].arrivetime,p[k].servicetime,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].dqzztime);}}//排序void sort(sjf *p,int N){for(int i=0;ifor(int j=0;jif(p[i].arrivetime{temp=p[i];p[i]=p[j];p[j]=}}//运行阶段void deal(sjf *p, float arrivetime,float servicetime,float starttime,float finishtime,float &zztime,float &dqzztime,int N){for(k=0;k{if(k==0){p[k].starttime=p[k].p[k].finishtime=p[k].arrivetime+p[k].}else{p[k].starttime=p[k-1].p[k].finishtime=p[k-1].finishtime+p[k].}}for(k=0;k{p[k].zztime=p[k].finishtime-p[k].p[k].dqzztime=p[k].zztime/p[k].}}void sjff(sjf *p,int N){float arrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0;//对结构进行初始化sort(p,N);for(int m=0;m{if(m==0)p[m].finishtime=p[m].arrivetime+p[m].elsep[m].finishtime=p[m-1].finishtime+p[m].int i=0;for(int n=m+1;n{if(p[n].arrivetime}float min=p[m+1].int next=m+1;//m+1=nfor(int k=m+1;k{if(p[k+1].servicetime{min=p[k+1].next=k+1;}}temp=p[m+1];p[m+1]=p[next];p[next]=}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
//物理页数#defineprintf("|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|\n")typedef struct PCB{int ID;int ReachTint TotalT Myprintf}PCB;{//进程号，到达时间和服务时间 typedef struct NOTE //备份 int ID; int TotalT}NOTE;PCB A[M];
//5个进程PCB a[M];NOTEint queue[50]; //记录调度的进程int K=0; //调度进程数组的标识void INIT()//初始化{ for(i=0;i}int GetNum()//计算进程数{int i,j=0; for(i=0;i}int GetReach(int time)//找出到达进程号{ for(i=0;iint GetInsert()//找出插入位置{ for(i=0;i}void Forward(int num)//前移{ for(i=0;i}void Process()//执行进程{queue[K]=A[0].ID; K++; A[0].TotalTime--; temp.ID=A[0].ID;temp.TotalTime=A[0].TotalT}void main(){ int t=0; printf("RR算法\n\n"); INIT(); for(i=0;iprintf("请输入服务时间：");
scanf("%d",&a[i].TotalTime); } for(i=0;i}}
} } else if(num==0)//进程数为0 else {
} Process(); Forward(num); if(temp.TotalTime!=0) {
} A[num-1].ID=temp.ID; A[num-1].TotalTime=temp.TotalT printf("\n"); printf("调度顺序为：\n"); M for(i=0;i八、实验数据及结果分析：短作业优先调度算法的实验结果：时间片轮转调度算法结果：九、实验结论：本次实验成功的完成了短作业优先调度算法和轮转时间片调度算法的模拟，通过本次实验我们了解到短作业优先调度算法不利于长作业的处理，因为长作业将长期得不到处理，而轮转时间片调度算法则解决了这一问题。短长作业均能在每一个周期内分得一个时间片处理自己的任务。十、总结及心得体会：通过本次实验对短作业优先调度算法和时间片轮转调度算法有了更深入的理解，同时，对程序算法能力有了进一步的提高，同时对模块化编程有了更深入得理解，代码的模块化会使程序的代码复用率提高，提高编程的效率。十一、对本实验过程及方法、手段的改进建议：本次实验的时间片轮转调度算法由于教材版本不一样有两种结果，本次实验本人采取的新教材的版本，新版本的难度较老教材要大很多，实验时候可以根据具体情况选择一个适合自己的来做。报告评分：
指导教师签字：
范文八：实验概述：实 验述： 实验目概及要求的 【】验实目的要及求】理解并掌处理握调机度法算【实验理】 实原验理】原于先来先服基调度务和最短作优业先度算调法想思用
语言编程C实现（使的软件 【用验实环】 使用的境软件）实验 环】 使用境的软件）（
Vsuil aC+6+.0实验内容：
实验内容：实验模本拟在处理机情单下况理机调处，度 用 语言编C实程先现来先服务和短作最业优调度先算法。【验实方设计案】 验方案实设】计FCFS流 程图：SFJ流 图程：验总设计流程图试：进等程时待＝间程开进运行始间时－进程提交间时即进程(于就处态时间)绪 程进周转间时＝程进束结间时进－提程交间时输作业入个、作数号、提交时业、间行时运间输入选数以选择调度择算法1其数2他FCFS算 法计算各 作参业数 ：开始间时，结束间 时待时等间，周时间转并输出 按 提照交时间序排错 继报续 输
数SJF 算再法按最短行时间运序排计算各业参作：数 先按提交时排间序开始 间时结束时， 等间时待，周转时间 并间输出实验【过程】实验 骤、记录步、数据分析、 ）（验步骤、实录、记据数分析）、测用试 1：例 幕屏示：Plea显e snipu thettotal
nmubreof job s 入：输 显：Pl示eaesi pun tjobnu bmr,es umit btmi aen rdnu imte输 ： 1入9 . 00.2
.85 05.回车38.
10. 车49.1 0. 1屏幕 显：What kind 示f oaglrithmod oyou
anwt ?lPaees nputi1 t osel ectFCFS, o
r 2t oelscetSJ .F 入：输 3 回屏幕示显Y：u ohvea nipu ta rwong unmebr, pelas einuptag ian.输 入：1回 屏幕出输果结：s bmiu rtunst arint fingla wia tturnraunod 38. 0 .10 .809 . 0.00 .1 208 . 5.0 5.099 .5 .0 150.9.01 .0 92.5 9. 705. 0. 7 941 0.1 9.. 97. 80. 60. 屏幕显示7：T ehav rege tarunaornd uite mi 0s.85 Whatki nd f oalgritohmdo
ou yawn?t lPaeesinp tu1 t o eselctFC S, For2 to s eeclt SF, oJr 0t
eoxt.i 测试数据： sub二itm urn1 6 0.
9 6.33 .01 CFFS和 SJ F算法结 果一样 s：bumt rin utasritng fnia l25
656.5 3 6 . 30. 615 6.6.T h aeerave tgrnauourd nime ti s0.56 测试数据7三 s：bumitr n 1u
052 . 4.22 0.33 5.1
.0 43 .25 01.F CS： Fusbmti un startrni finag 2l .42 03 ..4 4.5 12
0.5 5 2.52
531.0 3 ..25 55.4 5 2 0.1. 5. 5.6 T5h everaag eutnrrouna dite im 0.s25 3JFS s:bmut ruins artting fial 2 4n2 .03. 4. 42.51
.25 4 5. 2.01 5. 2.53
5.1 303. 53 5.6 .Th average eurnatounrdt me is 0.i25 源7程：序watitrunraunod
05. .2 0.03wita 00
0.1 0.3utrarnundo .3 002 0.4.0 .4wait
002.utnarrondu0. 30.
0.1 0.2#in5ludce"stdio h".# inluce"dstdlbih".#i nlucde"stingr.h"#defie M 50n srtct suj{f} spatic sttrutcsjf s [M];toidv ipnt(suturt scfj* ,inp Nt ){
rpitfn("leaseP niut pthejo
bnmbue,rsbuimt tie amn rundt im:en\or exmFlep:1 .5 820\n.)"; fro(i0;=ovd ipintrs(ructt jfs*p,int
) { N,p inrt("rfuno rdre:)";p rinf(t%d""p[0,.]obnjuber); mofr(k1;k%d-,p["k.]obnujmbre); rpntf(i\n"hTepr ceoss'si fnroation:m\")n;pr int(f\njo"bum\tsnumbti\truntsta\rttfin\a\ltawi\tturtanrond\n"); fuor(=0Npinrf("%dt\%t-.f1\t-.%f1t\%-1.\ft%.1-\t%-.1f\t%f-1f.\tn\,p"[k.jo]bunbmerp,[]k.subitmti }mg h/N=nif("\tThn eaeragvet ruanorud tnmieis %-.2f\ n,"g;}) /*按交提时间小从到排大序*/void
orst(1tsrut scfj *,int pN){ ,of(ir=0ifiro(=0;jj=iif()pi].s[ubmtitiem}/*运行/ *oivdde la(trust cjs f*p,itnN ){k frok(0;k=i(f=k0)=
{p[k]sta.tritem=p[k.subm]e [p].kinfishimet=[k].pubsmttiim+pe[k.]}els e { f(ipk[.su]bmititemp>k-[]1.inishtfiem) {p[ ].stkrttimae=[kp.s]p[ ]kfi.isnhtiem=pk][.ubsitmimte+p[]. e }lse e{ [kp.st]atrimt=pek-[].1[p].kinfsithie=mp[-1]kfin.sihtme+p[k]ir.u} } }
or(fk0=;;p[k].wittaimep[k].=sarttitm-epk[.]
}}oid vsotr2st(ucrtsjf * ,pnitN)
entxm,n,,k,osr1(tpN),o(m=0r;pm-1][fi.nihtsime)
{pm].f[niishimt=e[mp]s.umbitime+ptm][ru. m}e le psm][f.iinhstmi=epm[1]-f.inihsitm+e[m].rpntuime;f}o(n=m+1;rnNfi([pn.s]ubittimem=p,}voidm an(i)
i{n Nt,i; rintpf(P"elseai pnut thet tal onmbur of eobsj:");s anfc"%d"(&N),; inupt(s,tN; l)opo2:pintfr"Wha( ktni od alfogritmh o doyu wan?t Plese iapnut 1 otse elctFCFS
,r o2 tose eltcS J loop s:acfn"%d"(,&)i(i==f0 )ext(i1; els) ef(i=i1) {= ors1(st,N); detalst,N)( ;rpitns(t,N;) otg loop2; }o les efii(=2=){so rt2(s,Nt;)2}
p{irtfn(Y"uohave in put
warongnu merb p,leaesinpu
tagian":; )} }
（【论结】 果） 结论】 结结）果 试测1：试测：二测三试：【小】 小结】结实验中生产错误及的因分析原 实：中验生的产误及错因分析原：测用试例1
结的： 错果误 1：错误解决方式：要是主函数 子osr2t(中)出错：i 的作用域的，序程修改 将：来：原int
entx,mn,k,,i=; 0s otr(p,N1; )ofrm(=;m改为：ntinex tm,,, f,sort (1pN),;fo(mr=;0测试用例2 的结果：
错 1误错误：原因：未考虑 “提交到时间（subimttime大于）上进程的结束时间个的”情：况解决 法方 ：原来将的else： {[p]m.ifnsitihm=e[pm1].-inifshtie+mpm[.] } 改修为：e sel {i fp[(]m.sbumttime>i[m-p].1fnisitimh)e {p m][.finsihimetp[m=.su]mittbie+m[m]p.
}ele psm].[ifnihtsime=[pm-1]f.inishtim+pe[m].m}测试用
例3 结果的 错误 1：错误分析：：同
2 一样，未在子数函s rto(中未考)到虑“提交时间（sumittimbe大于上个）进的程束结间时的”况情：解 方法决： 原来将：的esel [mp].inifstimhep=m[-1]fi.inshtim+ep[m]ru.m修改为：lse {ei fp[m](sub.imtime>t[pm-1.f]iinshtmei { p[)m.fini]htime=p[m].ssbmuititemp[+]. e }lseep[m.f]nisihtme=i[p-1m.]ifishntim+p[m].实验}体会及收的获： 实验的体会及获：通收这过试次，我验处理对的调机度算特法是 F别CSF 和 SF J了有更的深理解而且锻，炼我了思的能维力， 使我能全更地思考面问，以题后需要多还做些方这面的练习。试验足之处不： 试验足之处不： 验未考试同虑时一间交提个进程多的况情，如测试数据：： submit ur n 71 02 2 7..20. 5
3 701. 果结该是应： CFS：F subit rmu sntat rinfal
710 2 7..0 7.5 37
01. 75 7..6 2 .2 075 7.. 678 T.h eaverge turnaraonduti m es i05..7 JS: FJobun msbmiu rtun stratin g 3 07. 170 1. 70 5 7.. 1 7.2 202 .7.6 heT avregeat rnaroundu itm eis0.43 .wait0 0. .5 0.04utnraorund .500 .6 .6f0inla7.
71.67 8.ait 0.w 0.0 1.0tur6arnuodn 0. 0.6 0.61程序运而结行是： 果而序程运行果结是：程结果表明序程该序是还存不在足之处。的是这要继需改进的地续。 指导教师方评语成绩：及指 教师评语及导成绩 评语： ：评语：成绩 成：绩：指导教师名： 签导指师签教名：批阅日 期 ：批阅日：期实验告说报明1．验实项目称名要：用最练的简言语反实映验内容。的求与实验要指导中书相一致 实验。目项称：名 目名称 2．项验类型实一般：需明是说验型实证验是还设型实验计，是新型创验还是实合型实验。综 验类实： 型．3实验的与要求目实 验的目要求与：目要明的，要确抓重点，符合实住验导书中的指要求。 与求要4实．验理原简要说：本实明项目验所涉及的论理识。 实验原理：知 ．5实验境：环实验的用软件环境硬（置配。）实验环境 6 ．验实方案计设思路、（步和骤方法等）：这实是验报告极其要的重内容。括概整个验实 实方验设案（计思、路骤和方法步等方 设计案过程
对于操作。型验 实作型操验实，要明依写何种据理原、操方作法行实进，要写明需要经验过哪几个操作型 验实 骤来实现其步操。作 于对计设型综合型和实验 计型和设综合型实，在验上内述基容础还上该应画流出程图设、计路和思计方 设设型计和合综型验实 ，再配以相法应的字文说明 对于创新型实验。创新 实验型，还注应明创其新点特色、。 新创实型验7 实．验过程（实验中涉的记录、数及据、析）：写分具体上述明实方验案具体的实施，包 实过程验实验中涉及（记的录、数、分据） 记析录括 实过验程的中录、记数据相应和的分析 8。．结论（结果：即）根实据过程中所验见到的现和测象的得数据做出，论结 。论（结结果）9．小结 对：本实次验的心体得会思、考建议和 。小结： 0．1导指教评师及成语：绩10 ．指教导师评及语成：指导绩教依据学师的实生际告内容报，简用练言给出本语实验次报 的评价告价和。 值注意 ：注意：o o实报验告记将入验实成； 绩次每实验始时，开交上次一的验实告，报则将否扣除次实此成绩。验
范文九：作业调度之最短作业优先算法5例题解析例题一、某系统采用不能移动已在主存储器中作业的可变分区方式管理主存储器，现有供用户使用的主存空间100K，系统配有4台磁带机，有一批作业见下表：作业序号 进输入井时间 要求计算时间 需要主存容量 申请磁带机数
1 10：00 25分钟 15K 2台
2 10：20 30分钟 60K 1台
3 10：30 10分钟 50K 3台
4 10：35 20分钟 10K 2台
5 10：40 15分钟 30K 2台 按计算时间最短者优先算法如下表：我的解释：系统首先装入1、2、4，但1结束时4沿未到达，因此先执行2；2执行完毕后，资源可以分配给3或5，考虑5的时间短优先分配5并执行，执行完5后，主存中只有4已就绪并等待执行，因此开始执行4，执行4的同时系统会将作业3装入主存，最后自然执行作业3；因此最后的顺序是： 1\2\5\4\3作业序号 进输入井时间 进入主存时间 开始计算时间 结束计算时间 周转时间 解释1
25此时输入井中只有一个作业且满足资源要求，因此被选中运行。2
35作业2到达输入井，满足资源要求，装入主存，等到作业1运行完毕进入运行。 5
30由于作业3要求主存空间无法满足，因此作业4先行一步装入主存，当作业2让出处理器的同时，作业5满足资源要求进入主存就绪。根据算法作业5先进入处理器运行。4
70最后作业3装入主存并运行平均周转时间：（25+35+30+55+70）/5＝43 分钟 ［分析］解答本题时应注意如下几个问题：第一，系统采用的是多道程序设计技术，但没有限定并行工作的道数，因此，只要当前尚未分配的资源可以满足在输入井中等待的某些作业的要求时，作业调度可以按照给定的算法从中选择一个或多个作业装人主存储器；第二，采用可变分区方式管理主存储器，但没给出主存空间的分配算法，因而，只要有合适的空间就可分配，题中还规定可用移动技术来合并分散的空闲区； 第三，对磁带机采用静态分配；第四，进程调度采用可抢占的最高优先级调度算法，即对已被装人主存储器的作业而言优先级高的作业可抢占处理器执行；第五，虽然作业需要使用磁带机，但题意中已提示忽略磁带机和调度所花的时间，所以，解题时不必考虑外围设备的启动二八D中断等复杂情况，只需把它们当作纯计算型的作业；第六，由于没有规定什么时候开始进行作业调度，故在一般情况下只要输入井中有等待处理的作业就可按选定的算法去选择满足必要条件的作业。 根据本题的要求列表分析如下：在10：3O时，作业（3）进人输入井，但因主存空闲空间虽然有40K却因被分成各为15K和25K的两个区域而不能用来装人作业（3）。当移动作业（2）后可把作业（3）装人主存储器，由于作业（3）的计算时间比作业（2）短，按规定的进程调度算法作业（3）可抢占处理器，致使作业（2）暂停运行。当作业（3）结束时已有作业（4）和（5）在输人井等待处理，它们都满足作业调度的必要条件，但由于作业（5）的计算时间短于作业（4），故先把作业（5）装人主存储器。现主存储器中有作业（2）和作业（5）两个作业，因作业（5）的优先级高于作业（2），故作业（2）的运行仍将被推迟。当作业（5）结束后作业调度又可选作业（4）进人主存储器，同样地，作业（4）抢先于作业（2）运行。可见，作业调度选中作业的次序为：（1）、（2）、（3）、（5）、（4），作业（2）是最后一个结束的作业且被移动过。「题解］(1）作业调度选中作业的次序依次为作业（1）、（2）、（3）、（5）、（4），最后一个执行结束的是作业（2）。（2）为了把作业（3）装人主存储器而移动了作业（2）。 （3）每个作业的周转时间可列表于下：五个作业的平均周转时间为：（25＋80＋10＋40＋15）／5＝170／5=34（分钟）例题二、.在一个多道程序系统，用户空间为100K，有四台打印机；采用在主存的作业不能移动的可变分区方式管理主存。主存空间采用最先适应分配算法，静态分配打印机；对作业采用计算时间短的作业优先调度算法管理。 今有如下所示的作业序列，请分别列出各个作业的执行时间和周转时间。注意：标准答案：JOB1 \JOB2 \JOB5 \JOB3 \JOB4解析：首批装入JOB1\JOB2\JOB4，由于JOB1首先到达先执行它，执行完后的时间是9，JOB2和JOB4按时间短算法，先执行JOB2，JOB2执行完后，正在主存就绪等待的是：“JOB4和JOB5” ， 再根据时间短算法我们优先执行JOB5，JOB5执行完后，正在主存就绪等待的是“JOB4和JOB3”，再根据时间短算法我们优先执行JOB3，最后执行JOB4，因此最终的作业序列是：“1-2-5-3-4”例题三、、在一个多道程序系统，供用户使用的主存空间有100K，采用计算时间短的作业优先算法。今有如下所示的作业序列，它们的提交时间、运行时间和对主存需求的数量在下表中所列，当第一个作业进入系统后开始调度，假定作业都是仅作计算，请列出各个作业的开始时间、完成时间和周转时间。注意：忽略系统开销。作业
进入输人井时间
需计算时间
15K标准答案：解析：内存空间有100K，首先装入1\2\4\5，根据时间顺序优先执行1，执行完1之后的时间是8.5，此时按短时间算法应该先执行5，但5沿未到达，因此我优先执行4，执行完4之后的时间点是8.6；此时按短时间算法我们继续执行5，执行完5之后虽剩余内存可分配给3，但作业2早已在主存就绪等待，我们优先执行作业2，最后再执行作业3；因此最终的作业序列是：1-4-5-2-3例题四、．一个多道程序系统，有一个作业序列，作业的提交时间及运行时间在下表中所列。当第一个作业进入系统后开始调度，假定作业都是仅作计算。请列出在分别采用先来先服务算法和计算时间短的优先算法管理作业时各个作业的开始时间、完成时间和周转时间。注意：忽略系统开销。 作业号
到达输入井时刻
需计算时间 1
0.2小时解析：当第一个作业进入系统后开始调度，没有疑问作业1首先执行，本题由于不受主存空间的分配限制，因此相对简单，依次计算即可完成短时间算法的相应问题。例题五、.在一个多道程序系统，采用响应比高者优先调度算法管理作业。今有如下所示的作业序列，它们的提交时间及运行时间如下表中所列。当第一个作业进入系统后开始调度。假定作业都是仅作计算。请列出各个作业的开始时间、完成时间和周转时间。注意：忽略系统开销。标准答案：解析：同例题四
范文十：课程设计报告书实践课题：姓
号：完成时间：指导老师：一、设计摘要利用C++,实现进程调度算法,有先来先服务、优先级调度、短作业优先、响应比高优先，进一步理解了进程调度各种算法的概念及含义。二、设计背景在OS中，调度的实质是一种资源分配，调度算法即指：根据系统的资源分配策略所规定的资源分配算法。对于不同的系统和系统目标，通常采用不同的调度算法，如在批处理系统中，为照顾为数众多的短作业，采用短作业有限调度算法；在分时系统中，为保证系统具有合理的响应时间，采用轮转法进行调度。采用算法时，则要考虑多方面因素，以便达到最佳效果。三、主要技术/算法简介#include #define MAX 10 struct task_struct
{char name[10];
/*进程名称*/
/*进程编号*/
float come_
/*到达时间*/
float run_begin_
/*开始运行时间*/
float run_
/*运行时间*/
float run_end_
/*运行结束时间*/
/*优先级*/
/*运行次序*/
/ *调度标志*/
}tasks[MAX];
/*实际进程个数*/ int fcfs();
/*先来先服务*/int ps();
/*优先级调度*/ int sjf();
/*短作业优先*/ int hrrn();
/*响应比高优先*/ int pinput();
/*进程参数输入*/ int poutput();
/ *调度结果输出*/void main() { pinput();printf("请选择调度算法（0~4）:\n"); printf("1.先来先服务\n"); printf("2.优先级调度\n"); printf("3.短作业优先\n"); printf("4.响应比高优先\n"); printf("0.退出\n"); scanf("%d",&option); switch (option) {
case 0:printf("运行结束。\n");
case 1:printf("对进程按先来先服务调度。\n\n");
poutput(); case 2:printf("对进程按优先级调度。\n\n");
ps();poutput(); case 3:printf("对进程按短作业优先调度。\n\n");
sjf();poutput(); case 4:printf("对进程按响应比高优先调度。\n\n");
poutput(); } }int fcfs()
/*先来先服务*/float time_temp=0;int number_time_temp=tasks[0].come_ for(i=0;itasks[i].run_begin_time=time_tasks[i].run_end_time=tasks[i].run_begin_time+tasks[i].run_
tasks[i].run_flag=1;time_temp=tasks[i].run_end_
number_schedul=i;tasks[number_schedul].order=i+1; }return 0; }int ps() /*优先级调度*/ {float temp_time=0; int i=0,j;int number_schedul,temp_ int max_max_priority=tasks[i]. j=1;while ((jif (tasks[j].priority>tasks[i].priority)
{max_priority=tasks[j].
/*查找第一个被调度的进程*/ /*对第一个被调度的进程求相应的参数*/ number_schedul=i;tasks[number_schedul].run_begin_time=tasks[number_schedul].come_tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_schedul].run_tasks[number_schedul].run_flag=1;temp_time=tasks[number_schedul].run_end_ tasks[number_schedul].order=1; temp_counter=1;while (temp_countermax_priority=0;for(j=0;jif((tasks[j].come_timemax_priority)
{max_priority=tasks[j].
number_schedul=j;
}/*查找下一个被调度的进程*//*对找到的下一个被调度的进程求相应的参数*/
tasks[number_schedul].run_begin_time=temp_tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_schedul].run_tasks[number_schedul].run_flag=1;temp_time=tasks[number_schedul].run_end_ temp_counter++;tasks[number_schedul].order=temp_}return 0; }int sjf()
/*短作业优先*/ {float temp_time=0; int i=0,j;int number_schedul,temp_ float run_run_time=tasks[i].run_ j=1;while ((jif (tasks[j].run_timerun_time=tasks[j].run_
/*查找第一个被调度的进程*/ /*对第一个被调度的进程求相应的参数*/ number_schedul=i;tasks[number_schedul].run_begin_time=tasks[number_schedul].come_tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_schedul].run_tasks[number_schedul].run_flag=1;temp_time=tasks[number_schedul].run_end_ tasks[number_schedul].order=1; temp_counter=1;while (temp_counterfor(j=0;jif((tasks[j].come_timerun_time=tasks[j].run_number_schedul=j;}}for(j=0;j{if((tasks[j].come_time/*查找下一个被调度的进程*//*对找到的下一个被调度的进程求相应的参数*/
tasks[number_schedul].run_begin_time=temp_tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_schedul].run_tasks[number_schedul].run_flag=1;temp_time=tasks[number_schedul].run_end_
temp_counter++;tasks[number_schedul].order=temp_
}return 0; }int hrrn() /*响应比高优先*/ {int j,number_schedul,temp_float temp_time,respond_rate,max_respond_ /*第一个进程被调度*/tasks[0].run_begin_time=tasks[0].come_tasks[0].run_end_time=tasks[0].run_begin_time+tasks[0].run_ temp_time=tasks[0].run_end_ tasks[0].run_flag=1; tasks[0].order=1; temp_counter=1; /*调度其他进程*/while(temp_countermax_respond_rate=0;
for(j=1;jif((tasks[j].come_time{respond_rate=(temp_time-tasks[j].come_time)/tasks[j].run_
if (respond_rate>max_respond_rate)
{max_respond_rate=respond_
number_schedul=j;
}/*找响应比高的进程*/tasks[number_schedul].run_begin_time=temp_tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_schedul].run_temp_time=tasks[number_schedul].run_end_
tasks[number_schedul].run_flag=1;
temp_counter+=1;tasks[number_schedul].order=temp_
}return 0; }int pinput() /*进程参数输入*/ {printf("please input the process counter:\n");
scanf("%d",&counter);for(i=0;i{ printf("******************************************\n");
printf("please input the process of %d th :\n",i+1);
printf("please input the name:\n");
scanf("%s",tasks[i].name);printf("please input the number:\n");
scanf("%d",&tasks[i].number);printf("please input the come_time:\n");
scanf("%f",&tasks[i].come_time);
printf("please input the run_time:\n");
scanf("%f",&tasks[i].run_time);
printf("please input the priority:\n");
scanf("%d",&tasks[i].priority);
tasks[i].run_begin_time=0;
tasks[i].run_end_time=0;
tasks[i].order=0;
tasks[i].run_flag=0; }return 0; }int poutput() /*调度结果输出*/ {float turn_round_time=0,f1,w=0;printf("name number come_time run_time run_begin_time run_end_time priority order turn_round_time\n"); for(i=0;if1=tasks[i].run_end_time-tasks[i].come_
turn_round_time+=f1;
w+=(f1/tasks[i].run_time);printf(" %s, %d, %5.3f, %5.3f, %5.3f, %5.3f, %d, %d, %5.3f\n",tasks[i].name,tasks[i].number,tasks[i].come_time,tasks[i].run_time,tasks[i].run_begin_time,tasks[i].run_end_time,tasks[i].priority,tasks[i].order,f1); }printf("average_turn_round_timer=%5.2f\n",turn_round_time/counter); printf("weight_average_turn_round_timer=%5.2f\n",w/counter); return 0; }三、设计运行情况截图 设有如下3个进程：注："优先级"一栏，数字大的表示优先级越高。 根据本例来运行本算法，结果如下： 1.输入进程有关参数采用先来先服务算法:采用优先级调度：采用短作业优先：采用高响应比优先：四、心得体会通过此次课程设计，更深入的理解了各个进程调度算法，及实现过程。在此过程中，遇到了困难，能及时请教同学，查询相关资料，及时解决了问题，但仍有不足之处，将会在今后学习中更加努力。