基于java进程调度算法模拟程序设计短作业优先先来先服务文档格式.docx
《基于java进程调度算法模拟程序设计短作业优先先来先服务文档格式.docx》由会员分享，可在线阅读，更多相关《基于java进程调度算法模拟程序设计短作业优先先来先服务文档格式.docx（15页珍藏版）》请在冰豆网上搜索。
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先来先服务算法==="
）;
\n到达时间是：
"
for（i=0;
i<
process_number;
i++）{
System.out.print（arrival_time[i]+"
\t"
}
\n服务时间是：
System.out.print（services_time[i]+"
\n开始时间是：
n[i]=arrival_time[i];
m[i]=i;
process_number-1;
for（j=i+1;
j<
j++）{
if（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;
if（arrival_time[m[i]]<
start_time[m[i-1]]+services_time[m[i-1]]）
start_time[m[i]]=start_time[m[i-1]]+services_time[m[i-1]];
else
start_time[m[i]]=arrival_time[m[i]];
System.out.print（start_time[i]+"
\n完成时间是：
completion_time[i]=start_time[i]+services_time[i];
System.out.print（completion_time[i]+"
\n周转时间是：
turn_around_time[i]=completion_time[i]-arrival_time[i];
System.out.print（turn_around_time[i]+"
add1=0;
add1=add1+turn_around_time[i];
\n平均周转时间是：
+add1/process_number）;
\n带权周转时间是：
right_turn_around_time[i]=turn_around_time[i]*1.0/services_time[i];
System.out.print（right_turn_around_time[i]+"
\n平均带权周转时间是：
add2=0;
add2=add2+right_turn_around_time[i];
System.out.println（add2/process_number）;
}
privatevoidSJF（）{
\n===SJF：
短作业优先算法==="
m[0]=0;
if（arrival_time[i]>
arrival_time[i+1]）
m[0]=i+1;
n[i]=services_time[i];
m[i+1]=i;
temp=m[i+1];
m[i+1]=m[j+1];
m[j+1]=temp;
process_number+1;
if（m[0]==m[i]）{
for（j=i;
m[j]=m[j+1];
add3=0;
add3=add3+turn_around_time[i];
+add3/process_number）;
add4=0;
add4=add4+right_turn_around_time[i];
System.out.println（add4/process_number）;
publicstaticvoidmain（String[]args）throwsException{
请输入进程数：
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;
\n请输入各进程到达时间"
wo.process_number;
str=buf.readLine（）;
wo.arrival_time[i]=Integer.parseInt（str）;
\n请输入各个进程服务时间"
str2=buf.readLine（）;
wo.services_time[i]=Integer.parseInt（str2）;
该进程数为"
+wo.process_number）;
\n到达时间为"
System.out.print（wo.arrival_time[i]+"
\n服务时间为：
System.out.print（wo.services_time[i]+"
\n======先来先服务【0】========"
\n======短作业优先【1】========"
\n======退出系统【2】========"
Stringstr3=null;
str3=buf.readLine（）;
i=Integer.parseInt（str3）;
while（i!
=2）{
switch（i）{
case0:
wo.FCFS（）;
break;
case1:
wo.SJF（）;
default:
System.out.println（"
\n输入有误，请重新输入"
系统已退出！
}
四、实验结果及分析
运行结果
分析
FCFS是最简单的调度算法，该算法既可用于作业调度，也可用于进度调度。
当在作业调度中采用该算法时，系统将按照作业到达的先后次序来进行调度，或者说它是优先考虑在系统中等待时间最长的作业，而不管该作业所需执行时间的长短，从后背作业队列中选择几个最先进入该队列的作业，将它们调入内存，为它们分配资源和创建进程。
然后把它放入就绪队列。
SJF算法是以作业长短来计算优先级，作业越短，其优先级越高。
作业的长短是以作业所要求的运行时间来衡量的。
SJF算法可以分别用于作业调度和进程调度。
在把短作业优先调度算法用于作业调度时，它将从外存的作业后备队列中选择若干个估计运行时间最短的作业，优先将它们调入内存运行。
教师评价
评定项目
A
B
C
D
算法正确
界面美观，布局合理
程序结构合理
操作熟练
语法、语义正确
解析完整
实验结果正确
文字流畅
报告规范
题解正确
其他：
评价教师签名：
年月日
升级会员 