操作系统先来先服务FCFS和短作业优先SJF进程调度算法Word格式文档下载.docx

上传人:b****3 文档编号:14128303 上传时间:2022-10-19 格式:DOCX 页数:12 大小:52.48KB
下载 相关 举报
操作系统先来先服务FCFS和短作业优先SJF进程调度算法Word格式文档下载.docx_第1页
第1页 / 共12页
操作系统先来先服务FCFS和短作业优先SJF进程调度算法Word格式文档下载.docx_第2页
第2页 / 共12页
操作系统先来先服务FCFS和短作业优先SJF进程调度算法Word格式文档下载.docx_第3页
第3页 / 共12页
操作系统先来先服务FCFS和短作业优先SJF进程调度算法Word格式文档下载.docx_第4页
第4页 / 共12页
操作系统先来先服务FCFS和短作业优先SJF进程调度算法Word格式文档下载.docx_第5页
第5页 / 共12页
点击查看更多>>
下载资源
资源描述

操作系统先来先服务FCFS和短作业优先SJF进程调度算法Word格式文档下载.docx

《操作系统先来先服务FCFS和短作业优先SJF进程调度算法Word格式文档下载.docx》由会员分享,可在线阅读,更多相关《操作系统先来先服务FCFS和短作业优先SJF进程调度算法Word格式文档下载.docx(12页珍藏版)》请在冰豆网上搜索。

操作系统先来先服务FCFS和短作业优先SJF进程调度算法Word格式文档下载.docx

设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。

假设有n个进程分别在T1,…,Tn时刻到达系统,它们需要的服务时间分别为S1,…,Sn。

分别采用先来先服务FCFS和短作业优先SJF进程调度算法进行调度,计算每个进程的完成时间、周转时间和带权周转时间,并且统计n个进程的平均周转时间和平均带权周转时间。

3、程序要求:

1)进程个数n;

每个进程的到达时间T1,…,Tn和服务时间S1,…,Sn;

选择算法1-FCFS,2-SJF。

2)要求采用先来先服务FCFS和短作业优先SJF分别调度进程运行,计算每个进程的周转时间和带权周转时间,并且计算所有进程的平均周转时间和带权平均周转时间;

3)输出:

要求模拟整个调度过程,输出每个时刻的进程运行状态,如“时刻3:

进程B开始运行”等等;

4)输出:

要求输出计算出来的每个进程的周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间。

4、需求分析

(1)输入的形式和输入值的范围

算法选择:

FCFS-“1”,选SJF-“2”

真实进程数

各进程的到达时间

各进程的服务时间

(2)输出的形式

模拟整个调度过程、周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间。

(3)程序所能达到的功能

输入进程个数Num,每个进程到达时间ArrivalTime[i],服务时间ServiceTime[i]。

采用先来先服务FCFS或者短作业优先SJF进程调度算法进行调度,计算每个进程的完成时间、周转时间和带权周转时间,并且统计Num个进程的平均周转时间和平均带权周转时间。

(4)测试用例

5、调试分析

(1)调试过程中遇到的问题以及解决方法,设计与实现的回顾讨论和分析

开始的时候没有判断进程是否到达,导致短进程优先算法运行结果错误,后来加上了判断语句后就解决了改问题。

基本完成的设计所要实现的功能,总的来说,FCFS编写容易,SJF需要先找到已经到达的进程,再从已经到达的进程里找到进程服务时间最短的进程,再进行计算。

根据我所写的FCFS和SJF算法,如果用户输入的数据没有按照到达时间的先后顺序,程序将出现问题?

解决办法:

利用冒泡排序,根据达到时间的先后顺序进行排序。

从第二个进程开始,算法需要判断已在等待的进程,如果分批进行判断与处理,规律性不强,代码很难实现?

通过牺牲效率的方式,进行一个个判断与处理。

为此,引入变量当前时间、用零标记已处理过进程等方式,实现已在等待进程的判断与判断。

(2)算法的改进设想

改进:

即使用户输入的进程到达时间没有先后顺序也能准确的计算出结果。

(就是再加个循环,判断各个进程的到达时间先后,组成一个有序的序列)

(3)经验和体会

通过本次实验,深入理解了先来先服务和短进程优先进程调度算法的思想,培养了自己的动手能力,通过实践加深了记忆。

6、测试结果

(1)FIFS算法:

文件流输入算法选择,进程个数,进程的达到时间和服务时间

输出

(2)FIFS算法:

7、附录(java)

packageexperiment;

importjava.io.BufferedInputStream;

importjava.io.;

importjava.text.DecimalFormat;

importjava.util.Scanner;

//先来先服务FCFS和短作业优先SJF进程调度算法

publicclassA_FJFS_SJF{

//声明变量

//允许的最大进程数

publicstaticintMaxNum=100;

//真正的进程数

publicstaticintrealNum;

//当前时间

publicstaticintNowTime;

//各进程的达到时间

publicstaticintArrivalTime[]=newint[MaxNum];

//各进程的服务时间

publicstaticintServiceTime[]=newint[MaxNum];

//各进程的服务时间(用于SJF中的临时数组)

publicstaticintServiceTime_SJF[]=newint[MaxNum];

//各进程的完成时间

publicstaticintFinishTime[]=newint[MaxNum];

//各进程的周转时间

publicstaticintWholeTime[]=newint[MaxNum];

//各进程的带权周转时间

publicstaticdoubleWeightWholeTime[]=newdouble[MaxNum];

//FCFS和SJF的平均周转时间

publicstaticdoubleAverageWT_FCFS,AverageWT_SJF;

//FCFS和SJF的平均带权周转时间

publicstaticdoubleAverageWWT_FCFS,AverageWWT_SJF;

//FCFS中的周转时间总和

publicstaticintSumWT_FCFS=0;

//FCFS中的带权周转时间总和

publicstaticdoubleSumWWT_FCFS=0;

//SJF中的周转时间总和

publicstaticintSumWT_SJF=0;

//SJF中的带权周转时间总和

publicstaticdoubleSumWWT_SJF=0;

publicstaticScannerstdin;

publicstaticvoidmain(Stringargs[])throws{

//从文件中输入数据

BufferedInputStreamin=newBufferedInputStream(new(

"

./"

));

System.setIn(in);

stdin=newScanner(System.in);

intchoice=stdin.nextInt();

//算法选择:

realNum=stdin.nextInt();

//真实进程数

for(inti=0;

i<

realNum;

i++){//各进程的到达时间

ArrivalTime[i]=stdin.nextInt();

}

for(intj=0;

j<

j++){//各进程的服务时间

ServiceTime[j]=stdin.nextInt();

ServiceTime_SJF[j]=ServiceTime[j];

stdin.close();

//算法选择:

1-FCFS,2-SJF;

if(choice==1){

FCFS();

}elseif(choice==2){

SJF();

}else{

System.out.println("

算法选择错误"

);

}

//先来先服务FCFS进程调度算法

publicstaticvoidFCFS(){

//到达时间的冒泡排序,完成时间随之变动(使先到者排在前面,后到者排在后面)

sort();

//计算每个进程的完成时间、周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间

FinishTime[0]=ArrivalTime[0]+ServiceTime[0];

WholeTime[0]=ServiceTime[0];

WeightWholeTime[0]=(double)WholeTime[0]/ServiceTime[0];

AverageWT_FCFS=AverageWWT_FCFS=0;

AverageWT_FCFS=AverageWT_FCFS+WholeTime[0];

AverageWWT_FCFS=AverageWWT_FCFS+WeightWholeTime[0];

for(intj=1;

j++){//从第二个进程开始计算完成时间、周转时间、带权周转时间

if(ArrivalTime[j]>

FinishTime[j-1]){//该进程是否在等待

FinishTime[j]=ArrivalTime[j]+ServiceTime[j];

WholeTime[j]=ServiceTime[j];

}else{//该进程已在等待

FinishTime[j]=FinishTime[j-1]+ServiceTime[j];

WholeTime[j]=FinishTime[j-1]-ArrivalTime[j]+ServiceTime[j];

}

WeightWholeTime[j]=(double)WholeTime[j]/ServiceTime[j];

i++){//计算总周转时间、总带权周转时间

SumWT_FCFS=SumWT_FCFS+WholeTime[i];

SumWWT_FCFS=SumWWT_FCFS+WeightWholeTime[i];

AverageWT_FCFS=(double)SumWT_FCFS/realNum;

//平均周转时间

AverageWWT_FCFS=(double)SumWWT_FCFS/realNum;

//平均带权周转时间

//输出每个进程的完成时间、周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间

outPUT

(1);

//短作业优先SJF进程调度算法

publicstaticvoidSJF(){

intmin=0;

NowTime=ArrivalTime[0]+ServiceTime[0];

//计算第一次的NowTIme

FinishTime[0]=ServiceTime[0];

//计算第一个进程的完成时间

ServiceTime_SJF[0]=1000;

//赋初值。

intallin=

展开阅读全文
相关资源
猜你喜欢
相关搜索

当前位置:首页 > IT计算机 > 电脑基础知识

copyright@ 2008-2022 冰豆网网站版权所有

经营许可证编号:鄂ICP备2022015515号-1