操作系统·用Java模拟作业调度算法

目的：

1. 理解等待时间、周转时间、平均周转时间等相关概念及其计算方法。
2. 掌握四种常用的作业调度算法（FCFS、SJF、HPF、HRRN），区分算法之间的差异性，并用高级语言模拟实现各算法。

   ---

   题目：

一、用高级语言编写四个作业调度的模拟程序（非抢占式）。 

1.采用先来先服务（First-Come First-Served，FCFS）调度算法，即按作业到达的先后次序进行调度。总是首先调度在系统中等待时间最长的作业。

2. 短作业优先 (Shortest-Job-First，SJF) 调度算法，优先调度要求运行时间最短的作业。

3.优先权高者优先（Highest-Priority-First，HPF）调度算法，为每个作业设置一个优先数，优先数高者优先调度。

4.响应比高者优先（Highest Response Ratio Next，HRRN）调度算法，计算每个作业的响应比，响应比＝ 作业周转时间 / 作业运行时间，数值越大越优先。

二、 模拟程序的功能

1.允许用户指定作业的个数，允许用户选择输入每个作业的到达时间和所需运行时间。

2.按照模拟数据的到达时间和所需运行时间，执行FCFS、 SJF、HPF和HRRN调度算法，程序计算各作业的开始执行时间，各作业的等待时间和周转时间。

3.能够对同一个模拟数据计算各算法的平均等待时间，平均周转时间，并进行比较。

---

Java代码实现：

• 模拟作业类：

public class Jcb {
	private String name;
	private int arr_time;//到达时间
	private int run_time;//运行时间
	private int wait_time;//等待时间
	private double c_time;//周转时间
	private int pri;//优先权
	private double response;//响应比
	private char sta;//状态
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getArr_time() {
		return arr_time;
	}
	public void setArr_time(int arr_time) {
		this.arr_time = arr_time;
	}
	public int getRun_time() {
		return run_time;
	}
	public void setRun_time(int run_time) {
		this.run_time = run_time;
	}
	public int getWait_time() {
		return wait_time;
	}
	public void setWait_time(int wait_time) {
		this.wait_time = wait_time;
	}
	public double getC_time() {
		return c_time;
	}
	public void setC_time(double c_time) {
		this.c_time = c_time;
	}
	public int getPri() {
		return pri;
	}
	public void setPri(int pri) {
		this.pri = pri;
	}
	public double getResponse() {
		return response;
	}
	public void setResponse(double response) {
		this.response = response;
	}
	public char getSta() {
		return sta;
	}
	public void setSta(char sta) {
		this.sta = sta;
	}
	
	public Jcb() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Jcb(String name, int arr_time, int run_time, int wait_time, double c_time, int pri, double response,
			char sta) {
		super();
		this.name = name;
		this.arr_time = arr_time;
		this.run_time = run_time;
		this.wait_time = wait_time;
		this.c_time = c_time;
		this.pri = pri;
		this.response = response;
		this.sta = sta;
	}
	@Override
	public String toString() {
		return "Jcb [name=" + name + ", arr_time=" + arr_time + ", run_time=" + run_time + ", wait_time=" + wait_time
				+ ", c_time=" + c_time + ", pri=" + pri + ", response=" + response + ", sta=" + sta + "]";
	}
	
}

• 算法测试类：

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Jcb [] job=new Jcb[7];
		intal_job(job);
		print(job);
		
		FCFS(job);//先来先服务
		Prepare(job);
		intal_job(job);
		SJF(job);//短作业优先
		Prepare(job);
		intal_job(job);
		HPF(job);//优先权高者优先
		Prepare(job);
		intal_job(job);
		HRRN(job);//响应比高者优先
		Prepare(job);
	}
	public static void intal_job(Jcb[] job) {
		int [] arr_time= {800,815,830,835,845,700,820};//到达时间
		int [] run_time= {50,30,25,20,15,10,5};//运行时间
		int [] pri= {0,1,2,3,4,1,0};//优先权
		for(int i=0;i<job.length;i++) {
			job[i]=new Jcb();
			job[i].setName((i+1)+"");
			job[i].setArr_time(arr_time[i]);
			job[i].setRun_time(run_time[i]);
			job[i].setPri(pri[i]);
			job[i].setSta('W');
		}
	}
	//输出
	public static void print(Jcb[]job) {
		for(int i=0;i<job.length;i++) {
			System.out.println(job[i]);
		}
		System.out.println();
	}
	//判断是否全部完成
	private static boolean fun(Jcb[] job) {
		for(int i=0;i<job.length;i++) {
			if(job[i].getSta()!='F') {
				return true;
			}
		}
		return false;
	}
	//比较
	public static void Prepare(Jcb [] job) {
		double wait=0;double ct=0;
		for(int i=0;i<job.length;i++) {
			wait=job[i].getWait_time()+wait;
			ct=job[i].getC_time()+ct;
		}
		wait=wait/7;
		ct=ct/7;
		System.out.println("平均等待时间："+wait+" 平均周转时间："+ct);
	}
	
	//先来先服务（First-Come First-Served，FCFS）调度算法
	//按作业到达的先后次序进行调度。总是首先调度在系统中等待时间最长的作业。
	public static void FCFS(Jcb [] job) {
		System.out.println("-------FCFS------");
		int c=700;//当前时间 700
		
		while(fun(job)) {
			int max=845;
			int min_i=-1;
			for(int i=0;i<job.length;i++) {
				if(job[i].getArr_time()<=c&&job[i].getSta()!='F') {
					if(job[i].getArr_time()<=max) {
						max=job[i].getArr_time();//修改开始时间
						min_i=i;//作业排序
					}
				}
			}
			if(min_i==-1) {
				c+=5;
				//System.out.println("c："+c);
			}else {
				job[min_i].setSta('R');
				job[min_i].setWait_time(c-job[min_i].getArr_time());
				print(job);//输出R的情况
				
				c=c+job[min_i].getRun_time();
				//System.out.println("c："+c);
				job[min_i].setSta('F');
				
				job[min_i].setC_time(c-job[min_i].getArr_time());
				print(job);//输出F的情况
			}
		}

	}
	
	//短作业优先 (Shortest-Job-First，SJF) 调度算法
	//优先调度要求运行时间最短的作业。
	public static void SJF(Jcb [] job) {
		System.out.println("-------SJF------");
		int c=700;//当前时间 700
		while(fun(job)) {
			int min=50;
			int min_i=-1;
			for(int i=0;i<job.length;i++) {
				if(job[i].getArr_time()<=c&&job[i].getSta()!='F') {
					if(job[i].getRun_time()<=min) {
						min=job[i].getRun_time();//修改最短作业时间
						min_i=i;//作业排序
					}
				}
			}
			if(min_i==-1) {
				c+=5;
			}else {
				job[min_i].setSta('R');
				job[min_i].setWait_time(c-job[min_i].getArr_time());
				print(job);//输出R的情况
				
				c+=job[min_i].getRun_time();
				job[min_i].setSta('F');
				
				job[min_i].setC_time(c-job[min_i].getArr_time());
				print(job);//输出F的情况
				min_i=-1;
			}
		}
	}
	
	//优先权高者优先（Highest-Priority-First，HPF）调度算法
	//为每个作业设置一个优先数，优先数高者优先调度。
	public static void HPF(Jcb [] job) {
		System.out.println("-------HPF------");
		int c=700;//当前时间 700
		while(fun(job)) {
			int min=4;
			int min_i=-1;
			for(int i=0;i<job.length;i++) {
				if(job[i].getArr_time()<=c&&job[i].getSta()!='F') {
					if(job[i].getPri()<=min) {
						min=job[i].getPri();//修改最高优先权
						min_i=i;//作业排序
					}
				}
			}
			if(min_i==-1) {
				c+=5;
			}else {
				job[min_i].setSta('R');
				job[min_i].setWait_time(c-job[min_i].getArr_time());
				print(job);//输出R的情况
				
				c+=job[min_i].getRun_time();
				job[min_i].setSta('F');
				
				job[min_i].setC_time(c-job[min_i].getArr_time());
				print(job);//输出F的情况
			}
		}
	}
	
	//计算响应比  响应比＝ 作业周转时间 / 作业运行时间，数值越大越优先。
	public static double Response(int c,Jcb [] job) {
		for(int i=0;i<job.length;i++) {
			if(job[i].getArr_time()<=c&&job[i].getSta()!='F') {
				job[i].setResponse((c-job[i].getArr_time())/job[i].getRun_time());
			}
		}
		//排序
		Jcb [] temp=new Jcb[1];//临时变量数组
		for(int n=0;n<job.length-1;n++) {
			for(int m=0;m<job.length-n-1;m++) {
				if(job[m+1].getResponse()<job[m].getResponse()) {
					temp[0]=job[m];
					job[m]=job[m+1];
					job[m+1]=temp[0];
				}
			}
		}
		return job[job.length-1].getResponse();
		/*int [] p=new int[job.length];
		for(int j=0;j<p.length;j++) {
			p[p.length-1]=Integer.parseInt(job[j].getName());
		}*/
	}
	//响应比高者优先（Highest Response Ratio Next，HRRN）调度算法
	//计算每个作业的响应比，响应比＝ 作业周转时间 / 作业运行时间，数值越大越优先。
	public static void HRRN(Jcb [] job) {
		System.out.println("-------HRRN------");
		int c=700;//当前时间 700
		while(fun(job)) {
			double max=Response(c,job);
			int min_i=-1;
			for(int i=0;i<job.length;i++) {
				if(job[i].getArr_time()<=c&&job[i].getSta()!='F') {
					if(job[i].getResponse()>=max) {
						max=job[i].getResponse();//修改最高响应比
						min_i=i;//作业排序
					}
				}
			}
			if(min_i==-1) {
				c+=5;
			}else {
				job[min_i].setSta('R');
				job[min_i].setWait_time(c-job[min_i].getArr_time());
				print(job);//输出R的情况

				c+=job[min_i].getRun_time();
				job[min_i].setSta('F');

				job[min_i].setC_time(c-job[min_i].getArr_time());
				print(job);//输出F的情况
			}
		}
	}
	


}