基于java进程调度算法模拟程序设计短作业优先先来先服务含源文件.docx
《基于java进程调度算法模拟程序设计短作业优先先来先服务含源文件.docx》由会员分享，可在线阅读，更多相关《基于java进程调度算法模拟程序设计短作业优先先来先服务含源文件.docx（15页珍藏版）》请在冰点文库上搜索。
基于java进程调度算法模拟程序设计短作业优先先来先服务含源文件
华北科技学院计算机学院综合性实验
实验报告
课程名称计算机操作系统
实验学期2014至2015学年第一学期
学生所在系部计算机学院
年级2012专业班级计科B121
学生姓名张传辉学号************
任课教师王祥仲
实验成绩
计算机学院制
《操作系统》课程综合性实验报告
开课实验室：
基础六2014年11月30日
实验题目
进程调度算法模拟程序设计
一、实验目的
通过对进程调度算法的模拟，进一步理解进程的基本概念，加深对进程运行状态和进程调度过程、调度算法的理解。
二、设备与环境
1.硬件设备：
PC机一台
2.软件环境：
安装Windows操作系统或者Linux操作系统，并安装相关的程序开发环境，如C\C++\Java等编程语言环境。
三、实验内容
（1）用C语言（或其它语言，如Java）编程实现对N个进程采用某种进程调度算法（如动态优先权调度算法、先来先服务算法、短进程优先算法、时间片轮转调度算法）调度执行的模拟。
（2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：
✧进程标识数ID。
✧进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。
✧进程已占用CPU时间CPUTIME。
✧进程还需占用的CPU时间ALLTIME。
当进程运行完毕时，ALLTIME变为0。
✧进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进入阻塞状态。
✧进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个时间片后，将转换成就绪状态。
✧进程状态STATE。
✧队列指针NEXT，用来将PCB排成队列。
（3）优先数改变的原则：
✧进程在就绪队列中呆一个时间片，优先数增加1。
✧进程每运行一个时间片，优先数减3。
（4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。
（5）分析程序运行的结果，谈一下自己的认识。
代码：
importjava.io.BufferedReader;
importjava.io.InputStreamReader;
publicclassFCFSANDSJF{
privatestaticinti;
privateintj;
privateinttemp;
privateintm[];
privateintn[];
privateintprocess_number;
privateintarrival_time[];
privateintservices_time[];
privateintstart_time[];
privateintcompletion_time[];
privateintturn_around_time[];
privatedoubleadd1;
privatedoubleadd2;
privatedoubleadd3;
privatedoubleadd4;
privatedoubleright_turn_around_time[];
privatevoidFCFS（）{
System.out.println（"\n===FCFS先来先服务算法==="）;
System.out.println（"\n到达时间是：
"）;
for（i=0;iSystem.out.print（arrival_time[i]+"\t"）;
}
System.out.println（"\n服务时间是：
"）;
for（i=0;iSystem.out.print（services_time[i]+"\t"）;
}
System.out.println（"\n开始时间是：
"）;
for（i=0;in[i]=arrival_time[i];
m[i]=i;
}
for（i=0;ifor（j=i+1;jif（n[i]>n[j]）{
temp=n[i];
n[i]=n[j];
n[j]=temp;
temp=m[i];
m[i]=m[j];
m[j]=temp;
}
}
}
start_time[m[0]]=arrival_time[m[0]];
for（i=1;iif（arrival_time[m[i]]start_time[m[i]]=start_time[m[i-1]]+services_time[m[i-1]];
else
start_time[m[i]]=arrival_time[m[i]];
}
for（i=0;iSystem.out.print（start_time[i]+"\t"）;
}
System.out.println（"\n完成时间是：
"）;
for（i=0;icompletion_time[i]=start_time[i]+services_time[i];
}
for（i=0;iSystem.out.print（completion_time[i]+"\t"）;
}
System.out.println（"\n周转时间是：
"）;
for（i=0;iturn_around_time[i]=completion_time[i]-arrival_time[i];
}
for（i=0;iSystem.out.print（turn_around_time[i]+"\t"）;
}
add1=0;
for（i=0;iadd1=add1+turn_around_time[i];
}
System.out.println（"\n平均周转时间是：
"+add1/process_number）;
System.out.println（"\n带权周转时间是：
"）;
for（i=0;iright_turn_around_time[i]=turn_around_time[i]*1.0/services_time[i];
}
for（i=0;iSystem.out.print（right_turn_around_time[i]+"\t"）;
}
System.out.println（"\n平均带权周转时间是：
"）;
add2=0;
for（i=0;iadd2=add2+right_turn_around_time[i];
}
System.out.println（add2/process_number）;
}
privatevoidSJF（）{
System.out.println（"\n===SJF：
短作业优先算法==="）;
System.out.println（"\n到达时间是：
"）;
for（i=0;iSystem.out.print（arrival_time[i]+"\t"）;
}
System.out.println（"\n服务时间是：
"）;
for（i=0;iSystem.out.print（services_time[i]+"\t"）;
}
System.out.println（"\n开始时间是：
"）;
m[0]=0;
for（i=0;iif（arrival_time[i]>arrival_time[i+1]）
m[0]=i+1;
}
for（i=0;in[i]=services_time[i];
m[i+1]=i;
}
for（i=0;ifor（j=i+1;jif（n[i]>n[j]）{
temp=n[i];
n[i]=n[j];
n[j]=temp;
temp=m[i+1];
m[i+1]=m[j+1];
m[j+1]=temp;
}
}
}
for（i=1;iif（m[0]==m[i]）{
for（j=i;jm[j]=m[j+1];
}
}
}
start_time[m[0]]=arrival_time[m[0]];
for（i=1;iif（arrival_time[m[i]]start_time[m[i]]=start_time[m[i-1]]+services_time[m[i-1]];
else
start_time[m[i]]=arrival_time[m[i]];
}
for（i=0;iSystem.out.print（start_time[i]+"\t"）;
}
System.out.println（"\n完成时间是：
"）;
for（i=0;icompletion_time[i]=start_time[i]+services_time[i];
}
for（i=0;iSystem.out.print（completion_time[i]+"\t"）;
}
System.out.println（"\n周转时间是：
"）;
for（i=0;iturn_around_time[i]=completion_time[i]-arrival_time[i];
}
for（i=0;iSystem.out.print（turn_around_time[i]+"\t"）;
}
add3=0;
for（i=0;iadd3=add3+turn_around_time[i];
}
System.out.println（"\n平均周转时间是：
"+add3/process_number）;
System.out.println（"\n带权周转时间是：
"）;
for（i=0;iright_turn_around_time[i]=turn_around_time[i]*1.0/services_time[i];
}
for（i=0;iSystem.out.print（right_turn_around_time[i]+"\t"）;
}
System.out.println（"\n平均带权周转时间是：
"）;
add4=0;
for（i=0;iadd4=add4+right_turn_around_time[i];
}
System.out.println（add4/process_number）;
}
publicstaticvoidmain（String[]args）throwsException{
System.out.println（"请输入进程数：
"）;
FCFSANDSJFwo=newFCFSANDSJF（）;
BufferedReaderbuf=null;
buf=newBufferedReader（newInputStreamReader（System.in））;
Stringstr1=null;
str1=buf.readLine（）;
wo.process_number=Integer.parseInt（str1）;
wo.arrival_time=newint[wo.process_number];
wo.services_time=newint[wo.process_number];
wo.start_time=newint[wo.process_number+1];
pletion_time=newint[wo.process_number+1];
wo.turn_around_time=newint[wo.process_number+1];
wo.right_turn_around_time=newdouble[wo.process_number+1];
wo.m=newint[wo.process_number+1];
wo.n=newint[wo.process_number];
Stringstr=null;
Stringstr2=null;
System.out.println（"\n请输入各进程到达时间"）;
for（i=0;istr=buf.readLine（）;
wo.arrival_time[i]=Integer.parseInt（str）;
}
System.out.println（"\n请输入各个进程服务时间"）;
for（i=0;istr2=buf.readLine（）;
wo.services_time[i]=Integer.parseInt（str2）;
}
System.out.println（"该进程数为"+wo.process_number）;
System.out.println（"\n到达时间为"）;
for（i=0;iSystem.out.print（wo.arrival_time[i]+"\t"）;
}
System.out.println（"\n服务时间为：
"）;
for（i=0;iSystem.out.print（wo.services_time[i]+"\t"）;
}
System.out.println（"\n======先来先服务【0】========"）;
System.out.println（"\n======短作业优先【1】========"）;
System.out.println（"\n======退出系统【2】========"）;
Stringstr3=null;
str3=buf.readLine（）;
i=Integer.parseInt（str3）;
while（i!
=2）{
switch（i）{
case0:
wo.FCFS（）;
break;
case1:
wo.SJF（）;
break;
default:
System.out.println（"\n输入有误，请重新输入"）;
}
System.out.println（"\n======先来先服务【0】========"）;
System.out.println（"\n======短作业优先【1】========"）;
System.out.println（"\n======退出系统【2】========"）;
str3=buf.readLine（）;
i=Integer.parseInt（str3）;
}
System.out.println（"系统已退出！
"）;
}
}
四、实验结果及分析
运行结果
分析
FCFS是最简单的调度算法，该算法既可用于作业调度，也可用于进度调度。
当在作业调度中采用该算法时，系统将按照作业到达的先后次序来进行调度，或者说它是优先考虑在系统中等待时间最长的作业，而不管该作业所需执行时间的长短，从后背作业队列中选择几个最先进入该队列的作业，将它们调入内存，为它们分配资源和创建进程。
然后把它放入就绪队列。
SJF算法是以作业长短来计算优先级，作业越短，其优先级越高。
作业的长短是以作业所要求的运行时间来衡量的。
SJF算法可以分别用于作业调度和进程调度。
在把短作业优先调度算法用于作业调度时，它将从外存的作业后备队列中选择若干个估计运行时间最短的作业，优先将它们调入内存运行。
教师评价
评定项目
A
B
C
D
评定项目
A
B
C
D
算法正确
界面美观，布局合理
程序结构合理
操作熟练
语法、语义正确
解析完整
实验结果正确
文字流畅
报告规范
题解正确
其他：
评价教师签名：
年月日
升级会员 