你的分享就是我们的动力 ---﹥

操作系统的调度算法实现(FCFS,SJF)

时间:2013-05-16 16:48来源:www.chengxuyuans.com 点击:

代码简介

操作系统的作业调度算法的实现(分别用先来先服务算法、短作业优先和响应比高者优先三种算法给出作业的调度顺序)
,响应比高者优先的还没做,不过很快会完善的

代码片段

public class Work {
	/** 作业名*/
	private String name;
	/** 作业到达时间*/
	private int arrivalTime;
	/** 作业服务时间*/
	private int serviceTime;
	/** 开始执行时间*/
	private int beginTime;
	/** 完成时间*/
	private int endTime;
	/** 作业是否调入系统*/
	private boolean in=false;
	/**
	 * 作业已调入
	 */
	public void setIn(){
		this.in=true;
	}
	/**
	 * 判断作业是否已调入系统
	 * @return
	 */
	public boolean isIn(){
		return this.in;
	}
	/**
	 * Constructor
	 * @param name
	 * @param t1
	 * @param t2
	 */
	public Work(String name,int t1,int t2){
		this.name=name;
		this.arrivalTime=t1;
		this.serviceTime=t2;
	}
	/**
	 * 设置开始执行时间
	 * @param t
	 */
	public void setBeginTime(int t){
		this.beginTime=t;
	}
	/**
	 * 获取开始时间
	 * @return
	 */
	public int getBeginTime(){
		return this.beginTime;
	}
	/**
	 * 设置完成时间
	 * @param t
	 */
	public void setEndTime(int t){
		this.endTime=t;
	}
	/**
	 * 获取结束时间
	 * @return
	 */
	public int getEndTime(){
		return this.endTime;
	}
	/**
	 * 计算“周转时间”=完成时间-到达时间
	 * @return int
	 */
	public int getCircleTime(){
		return this.endTime-this.arrivalTime;
	}
	/**
	 * 计算“带权周转时间”=周转时间/服务时间
	 * @return
	 */
	public double getCircleWPTime(){
		
		
		return getCircleTime()/this.serviceTime;
	}
	/**
	 * 计算"响应比"=(等待时间+要求服务时间)/要求服务时间=响应时间/要求服务时间
	 * @return
	 */
	public int getPriority(){
		//TODO
		
		return 0;
	}
	/**
	 *获取到达时间
	 * @return
	 */
	public int getArrivalTime(){
		return this.arrivalTime;
	}
	/**
	 * 获取服务时间
	 * @return
	 */
	public int getServiceTime(){
		return this.serviceTime;
	}
}
//-------------------------Test.java

import java.util.ArrayList;
import java.util.List;


public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Work A=new Work("A",0,6);
		Work B=new Work("B",2,50);
		Work C=new Work("C",5,20);
		Work D=new Work("D",5,10);
		Work E=new Work("E",12,40);
		Work F=new Work("F",15,8);
		List<Work> works=new ArrayList<Work>();
		works.add(A);
		works.add(B);
		works.add(C);
		works.add(D);
		works.add(E);
		works.add(F);
		//调用FCFS算法
		List<Double> list=FCFS(works);
		System.out.println("FCFS的算法的平均周转时间"+list.get(0));
		System.out.println("FCFS的算法的平均带权周转时间"+list.get(1));
		//list.remove(0);
		//list.remove(1);
		list=SJF(works);
		System.out.println("SJF的算法的平均周转时间"+list.get(0));
		System.out.println("SJF的算法的平均带权周转时间"+list.get(1));
	}
	/**
	 * 先来先服务调度算法
	 * @param works
	 * @return
	 */
	public static List<Double> FCFS(List<Work> works){
		double avgCircleTime=0;
		double avgCircleTimeWP=0;
		List<Double> lst=new ArrayList<Double>();
		for (int i = 0; i < works.size(); i++) {
		//	works.get(i).getArrivalTime();
		//	works.get(i).getServiceTime();
			if(i!=0){
				works.get(i).setBeginTime(works.get(i-1).getEndTime());
			}else{
				works.get(i).setBeginTime(works.get(i).getArrivalTime());
			}
			works.get(i).setEndTime(works.get(i).getBeginTime()+works.get(i).getServiceTime());
			avgCircleTime+=works.get(i).getCircleTime();
			avgCircleTimeWP+=works.get(i).getCircleWPTime();
		}
		avgCircleTime/=works.size();
		avgCircleTimeWP/=works.size();
		lst.add(avgCircleTime);
		lst.add(avgCircleTimeWP);
		return lst;
	}
	/**
	 * 短作业优先调度算法
	 * @param works
	 * @return
	 */
	public static List<Double> SJF(List<Work> works){
		List<Double> lst=new ArrayList<Double>();
		double avgCircleTime=0;
		double avgCircleTimeWP=0;
		int lastOneComeIn = works.get(works.size()-1).getArrivalTime();
		List<Work> ins=new ArrayList<Work>();
		int i=0;
		while (i <= lastOneComeIn) {
			//相当一个时钟的作用
			for (int j = 0; j < works.size(); j++) {
				if (works.get(j).getArrivalTime() <= i) {
					ins.add(works.get(j));
					//如果后续的作业也满足达到时间在当前时间之前,那么也加入系统中
					while (j+1<works.size()&&works.get(j + 1).getArrivalTime() <=i) {
						ins.add(works.get(j + 1));
						j++;
					}
					ins=sortByServiceTime(ins);
					for (int k = 0; k < ins.size(); k++) {
						//开始按段作业
						Work now=ins.get(k);
						if (k != 0) {
							Work last=ins.get(k-1);
							now.setBeginTime(last.getEndTime());
						} else {
							now.setBeginTime(now.getArrivalTime());
						}
						now.setEndTime(now.getBeginTime()+now.getServiceTime());
						i=now.getEndTime();
						ins.remove(k);
						//计算周转时间和带权周转时间的总和
					}
					
				}else{
					j--;
					i++;
					break;
				}
			}
			//判断是否所有的作业都已调入系统,如果已调入,则退出第一个while循环体
			if(i>lastOneComeIn){
				break;
			}
		}
		for (int m = 0; m< works.size(); m++) {
			avgCircleTime+=works.get(m).getCircleTime();
			avgCircleTimeWP+=works.get(m).getCircleWPTime();
		}
		avgCircleTime=avgCircleTime/works.size();
		avgCircleTimeWP=avgCircleTimeWP/works.size();
		lst.add(avgCircleTime);
		lst.add(avgCircleTimeWP);
		return lst;
	}
	/**
	 * 优先权调度算法
	 * @param works
	 * @return
	 */
	public static int PF(Work [] works){
		//TODO
		return 0;
	}
	/**
	 * 对加入到系统中的作业依据服务时间多少进行排序<BR>
	 * 然后直接返回
	 * @param ins
	 * @return ins
	 */
	public static List<Work> sortByServiceTime(List<Work> ins){
		for (int i = 0; i < ins.size(); i++) {
			for(int j=i+1;j<ins.size();j++){
				Work aw=ins.get(i);
				int a=aw.getServiceTime();
				Work bw=ins.get(j);
				int b=bw.getServiceTime();
				if(a>b){
					ins.remove(j);
					ins.add(i, bw);
				}
			}
		}
		return ins;
	}

}

转载注明地址http://www.chengxuyuans.com/code/java/60573.html