实验四

实验四进程调度算法的模拟实现

实验目的：

1：理解和掌握课堂上讲的进程调度算法，并编程模拟实现调度过程。 2：进程调度算法的实现方法

实验内容：

编程模拟实现进程调度算法：FCFS算法和SPJ算法

运行结果如下：

程序清单：

进程类：

package homework;

import java.text.DecimalFormat;

publicclass Process {

int pid; // pid表示进程的进程号

String pname; //name表示进程的名称

double arr_t; //arr_t表示进程的到达时间

double ser_t; //ser_t表示进程要求服务时间

double fin_t; //fin_t表示进程的完成时间

double t_t; //t_t表示进程的周转时间

double w_t; //w_t表示进程的带权周转时间

public Process(int pid,String name,double d,double e){ this.pid = pid;

this.pname = name;

this.arr_t = d;

this.ser_t = e;

}

//计算周转时间：完成时间 - 到达时间

publicvoid setT_t() {

t_t = fin_t - arr_t;

}

//计算带权周转时间：周转时间 / 服务时间

publicvoid setW_t() {

w_t = t_t /this.ser_t;

}

//打印进程的相关信息

public String toString() {

java.text.DecimalFormat df =new

java.text.DecimalFormat("###############0.000");

return"Process"+pid+";"+"进程名："+pname+""+"完成时间：

"+df.format(fin_t)+""+"周转时间："+df.format(t_t)+""+"带权周转时间："+df.format(w_t);

}

}

测试类：

package homework;

import java.util.Scanner;

publicclass Moni {

publicstaticvoid main(String[] args) {

// TODO Auto-generated method stub

Process[] p = new Process[5];//定义一个进程数组，用于存放测试进程信息

//初始化测试进程，

p[0] = new Process(1,"PA",8.0,1.0);

p[1] = new Process(2,"PB",8.5,0.5);

p[2] = new Process(3,"PC",9.0,0.2);

p[3] = new Process(4,"PD",9.1,0.1);

p[4] = new Process(5,"PE",9.8,0.6);

//用户输入不同数字选择不同算法，进行操作系统的模拟调度

Scanner scan = new Scanner(System.in);

System.out.println("请选择：1-FCFS 2-SJF");

int select =scan.nextInt();

if(select==1){

FCFS(p);

}

elseif(select == 2){

SPJ(p);

}

else{

System.out.println("请重新输入：");

}

}

;

//FCFS算法

publicstaticvoid FCFS(Process[] p){

//对存放进程的数组P按照进程的到达时间进行升序排序

for(int i = 0 ; i < 5 ; i++){

for( int j = i;j < 4; j++){

if(p[j].arr_t> p[j+1].arr_t){

double temp;

temp = p[j].arr_t;

p[j].arr_t = p[j+1].arr_t;

p[j+1].arr_t = temp;

}

}

}

//按照FCFS算法模拟操作系统对进程的调度

double finish_time = p[0].arr_t; //用于记录上一个进程的完成时间，用于计算该进程的完成时间

for(int i = 0 ; i < 5 ; i++){

p[i].fin_t = finish_time+ p[i].ser_t; //计算完成时间

finish_time = p[i].fin_t ;

p[i].setT_t(); //计算周转时间

p[i].setW_t(); //计算带权周转时间

System.out.println(p[i].toString()); //依照进程的执行顺序输出各进程的执行信息

}

}

//SPJ算法

publicstaticvoid SPJ(Process[] p){

double finish_time = p[0].arr_t; //用于记录上一个进程的完成时间，用于查找短作业和计算该进程的完成时间

for(int i = 0 ; i < 5 ; i++){ //外层循环用于进程的调度次数

int num = i;

double min_time = 1000;

for( int j = 0;j < 5; j++){ // 内层循环：每次调度时，从满足条件的进程中选取最短作业

//最短作业需要满足的条件：到达时间<=上一个进程的完成时间，还未被调度，服务时间是满足前两个条件的进程中最短的

if(p[j].ser_t

p[j].fin_t==0.0){

min_time = p[j].ser_t;

num = j ;

}

}

p[num].fin_t = finish_time+ p[num].ser_t; //计算完成时间

finish_time = p[num].fin_t ;

p[num].setT_t(); //计算周转时间

p[num].setW_t(); //计算带权周转时间

System.out.println(p[num].toString()); //依照进程的执行顺序输出各进程的执行信息

}

}

}

实验总结：

FCFS算法和SPJ算法的比较：

1：FCFS算法较SPJ算法实现简单，只需根据进程的到达时间调度即可，而SPJ算法则需要到达时间，服务时间共同决定进程的调度。

2：FCFS算法优先考虑在系统中等待时间最长的作业，按照到达的时间先后进行调度，故不利于短作业。而FCFS算法按照作业的长短进行调度，利于短作业，但对长作业不利。SPJ算法完全不考虑作业的等待时间，因此可能会出现饥饿现象。

3：FCFS算法和SPJ算法都没有考虑进程的紧迫程度。因此，均不能实现人-机交互。