操作系统 调度算法实验

首先，我是用java写的，当然的面向对象的思想设计。。

设计思路是模拟。按时间一个单位单位的处理。。。每运行一个时间单位，加入到达的进程（开始时间小于当前时间的），然后处理运行的进程，处理运行的队列。

进程类：包含进程的相关信息（名，开始时间，服务时间，优先级，运行时间，完成时间）

队列：完成先进先出功能，还实现了优先队列。。（没有考虑效率。嘿嘿，作业而已。。。）

运行：设置了准备队列（按开始时间排序,等待运行时间到达加入运行队列），运行队列（就绪等待调度的队列），完成队列（运行完成的进程），正在运行的进程（正在运行的进程，没有为空），时间（当前运行的时间，初值为-1，运行一次后为刚开始第0时间的状态。。）

主函数：输入，调用运行类运行，输出。

代码可以到（http://pan.baidu.com/s/1mg9JkNY）下载。这里粘出一部分。。。。

process类：

package test2;

/**
 * 
* @ClassName: Process 
* @Description: TODO(进程对象) 
* @author 朱争光      1023024917@qq.com  
* @date 2014-4-9 下午10:16:00 
*
 */
public class Process {
	private static  int id=0;//用途：设置默认id
	private String Proname;//进程名
	private int stratTime;//进程的到达时间
	private int serviceTime;//进程的服务时间
	private int level;//优先级，数值越小优先权越高
	private char proState;//进程状态（W——等待,R——运行,F——完成）
	private int runTime;//已经执行了多少时间
	private int finishTime;//完成时用了多少时间
	
	public  Process (){
		this.stratTime=0;
		this.serviceTime=0;
		this.proState='W';
		this.finishTime=0;
		this.level=0;
	}
	public  Process (int stratTime,int serviceTime ){
		this();
		this.stratTime=stratTime;
		this.serviceTime=serviceTime;
		
	} 
	public String toString (int style){
		if(style==ProcessStyle.OnlyProname){
			return this.Proname;
		}else if(style==ProcessStyle.runFinishTime){
			return this.Proname+"("+this.stratTime+","+this.serviceTime+","+this.runTime+","+this.finishTime+")"; 
		}else{
			return this.Proname+"("+this.stratTime+","+this.serviceTime+","+this.level+","+this.runTime+","+this.finishTime+")"; 
		}
	}
	public  void SetAutoProname (){
		this.Proname="Pro"+id;
		id++;
	}
	public String getProname() {
		return Proname;
	}
	public void setProname(String proname) {
		Proname = proname;
	}
	public int getStratTime() {
		return stratTime;
	}
	public void setStratTime(int stratTime) {
		this.stratTime = stratTime;
	}
	public int getServiceTime() {
		return serviceTime;
	}
	public void setServiceTime(int serviceTime) {
		this.serviceTime = serviceTime;
	}
	public char getProState() {
		return proState;
	}
	public void setProState(char proState) {
		this.proState = proState;
	}
	public int getRunTime() {
		return runTime;
	}
	public void setRunTime(int runTime) {
		this.runTime = runTime;
	}
	public int getFinishTime() {
		return finishTime;
	}
	public void setFinishTime(int finishTime) {
		this.finishTime = finishTime;
	}
	public static int getId() {
		return id;
	}
	public static void setId(int id) {
		Process.id = id;
	}
	public int getLevel() {
		return level;
	}
	public void setLevel(int level) {
		this.level = level;
	}
	
	
	
}

run类：

package test2;

import java.util.ArrayList;
import java.util.List;
/**
 * 
* @ClassName: Run 
* @Description: TODO(处理机调度) 
* @author 朱争光 1023024917@qq.com   
* @date 2014-4-10 下午5:03:51 
*
 */
public abstract class Run {
	  List<Process> readylist=new ArrayList<Process>();//所有初始化进程(有序，开始时间降序)
	  Queue<Process> runlist=new Queue<Process>();//进入执行的进程
	  List<Process> finishList=new ArrayList<Process>();//完成队列
	  Process runProcess;//保持正在运行的进程
	  int tip=-1;//保存当前运行时间单位，初始化为-1为运行，执行一次进入t=0状态
	  /**
	   * 
	  * @Title: addProcess 
	  * @Description: TODO(根据开始时间顺序添加进程) 
	  * @param process
	  * @return  int
	  * @throws
	   */
	  private int addProcess (Process process){
			process.setRunTime(0);
			process.setFinishTime(0);
			process.setProState('W');
			int flag=0;
			for(int i=readylist.size()-1;i>=0;i--){
				if(readylist.get(i).getStratTime()<process.getStratTime()){
					readylist.add(i,process);
					flag=i+1;
					break;
				}
			}
			if(flag==0)
				readylist.add(process);
			
			return flag;
		}
		/**
		 * 
		* @Title: setReadylist 
		* @Description: TODO(加入初始化队列) 
		* @param readylist  void
		* @throws
		 */
		public void setReadylist(List<Process> readylist) {
			for (Process process : readylist) {
				addProcess(process);
			}
			
		}

	  abstract public boolean  AddRunlistFromReadyListByTip();//根据时间把进程加入运行队列
	  abstract public boolean run ();//处理机调度，执行1个单位时间
	  /**
	   * 
	  * @Title: runToEnd 
	  * @Description: TODO(执行调度知道完成) 
	  * @return  boolean
	  * @throws
	   */
	  public boolean runToEnd (){
			while(isEnd ()){
				run();
				if(tip>0&&tip%100==0){
					System.out.println("怀疑为无法完成调度，已停止，可以继续执行");
					return false;
				}
			}
			return true;
		}
	  /**
	   * 
	  * @Title: isEnd 
	  * @Description: TODO(判断是否完成调度) 
	  * @return  boolean
	  * @throws
	   */
	  public boolean isEnd (){
			if(runlist.size()>0||readylist.size()>0||runProcess!=null){
				return false;
			}
			else {
				return true;
			}	
			
		}
	  //输出当前状态  参数为进程输出格式
	  public String  toString (int outStyle){
			StringBuilder sBuilder=new StringBuilder();
			sBuilder.append(tip+"-"+(tip+1));
			while(sBuilder.length()<10) sBuilder.append(' ');
			
			if(runProcess!=null){
				sBuilder.append(runProcess.toString(ProcessStyle.all));
			}else {
				sBuilder.append("none");
			}
			while(sBuilder.length()<30) sBuilder.append(' ');
			sBuilder.append("(");
			for (int i = 0; i < finishList.size(); i++) {
				sBuilder.append(finishList.get(i).toString(outStyle)+"<--");
			}
			sBuilder.append(")");
			while(sBuilder.length()<60) sBuilder.append(' ');
			
			sBuilder.append("(");
			for (int i = 0; i < runlist.size(); i++) {
				sBuilder.append(runlist.get(i).toString(outStyle)+"<--");
			}
			sBuilder.append(")");
			while(sBuilder.length()<100) sBuilder.append(' ');
			
			sBuilder.append("(");
			for (int i = readylist.size()-1; i >=0 ; i--) {
				sBuilder.append(readylist.get(i).toString(outStyle)+"<--");
			}
			sBuilder.append(") ");
			return sBuilder.toString();
		} 
		public List<Process> getReadylist() {
			return readylist;
		}
		public Queue<Process> getRunlist() {
			return runlist;
		}
		
		public List<Process> getFinishList() {
			return finishList;
		}
		public Process getRunProcess() {
			return runProcess;
		}
		public int getTip() {
			return tip;
		}
	  
}

main类：

package test2;

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

public class MainRR {
	private  Scanner cin;
	private  List<Process> scanf(){
		List<Process> list=new ArrayList<Process>();
	
		
		System.out.println("--------输入输出菜单  (输入‘END’返回上级)--------");
		System.out.println("请输入进程信息：");
		System.out.println("进程名(输入‘a’为自动生成)    进程的到达时间     进程的服务时间 ");
		System.out.println("例：‘a 0 1’ ");
		
		while(true){
			try {
				
				String name=cin.next();
				if("END".equals(name.toUpperCase())){
					break;
				}
				Process process=new Process();
				if("a".equals(name)==false){
					process.setProname(name);
				}else {
					process.SetAutoProname();
				}
				process.setStratTime(cin.nextInt());
				process.setServiceTime(cin.nextInt());
				list.add(process);
				System.out.println(process.getProname()+"输入完成");
			} catch (Exception e) {
				System.out.println("输入失败，请重试(输入‘END’返回上级)");
			}
			
		}
		return list;
	}
	
	private  void printf(List<Process> list){
		if(list==null){
			System.out.println("请先输入。。。");
		}else {
			System.out.println("--------输出菜单--------");
			System.out.println("请设置时间片（正整数）:");
			int timeSlice=1;
			try {
				 timeSlice=cin.nextInt();
			} catch (Exception e) {
				// TODO: handle exception
				System.out.println("时间片设置失败。。。");
				return;
			}
			
			while(true){
				
				System.out.println("A:输出执行过程    A-n:执行n个时间单位的结果     B:计算周转时间  (输入‘END’返回上级)" );
				String name=cin.next();
				if("END".equals(name.toUpperCase())){
					break;
				}else if ("A".equals(name.toUpperCase())) {
					System.out.println("时间\t 正在运行进程(开始时间，服务时间，优先级。运行时间，完成时间)\t\t 完成队列 \t\t 就绪队列 \t\t 未加入队列\t");
					
					RunRR runRR=new RunRR(list);
					runRR.setTimeSlice(timeSlice);
					while(true){
						runRR.run();
						System.out.println(runRR.toString(ProcessStyle.OnlyProname));
						
						if (runRR.isEnd()) {
							break;
						}
						if(runRR.getTip()>0&&runRR.getTip()%100==0){
							System.out.println("怀疑为无法完成调度，已停止，可以继续执行");
							System.out.println("是否继续执行？（Y/N）");
							if("N".equals(cin.next().toUpperCase())){
								break;
							}
						}
					}	
				}else if (name.length()>1&&"A-".equals(name.toUpperCase().subSequence(0, 2))) {
					System.out.println("时间\t 正在运行进程(开始时间，服务时间，优先级。运行时间，完成时间)\t\t 完成队列 \t\t 就绪队列 \t\t 未加入队列\t");
					try {
						int i=Integer.parseInt(name.substring(2));
						
						RunRR runRR=new RunRR(list);
						runRR.setTimeSlice(timeSlice);
						while(i-->=0){
							runRR.run();
							System.out.println(runRR.toString(ProcessStyle.OnlyProname));
							
							if (runRR.isEnd()) {
								break;
							}
							if(runRR.getTip()>0&&runRR.getTip()%100==0){
								System.out.println("怀疑为无法完成调度，已停止，可以继续执行");
								System.out.println("是否继续执行？（Y/N）");
								if("N".equals(cin.next().toUpperCase())){
									break;
								}
							}
						}	
					} catch (Exception e) {
						System.out.println("输入格式不对，请重新输入");
						// TODO: handle exception
					}
				}else if ("B".equals(name.toUpperCase())) {
					
					RunRR runRR=new RunRR(list);
					runRR.setTimeSlice(timeSlice);
					while(true){
						
						runRR.run();
						//System.out.println(runRR.toString(ProcessStyle.OnlyProname));
						if (runRR.isEnd()) {
							break;
						}
						if(runRR.getTip()>0&&runRR.getTip()%100==0){
							System.out.println("怀疑为无法完成调度，已停止，可以继续执行");
							System.out.println("是否继续执行？（Y/N）");
							if("N".equals(cin.next().toUpperCase())){
								break;
							}
						}
					}	
					if(runRR.isEnd()==false){
						System.out.println("未能完成调度，无法计算");
					}else {
						
						double sn=0; 
						List<Process> list2=runRR.getFinishList();
						String [] s=new String [list2.size()];
						for(int i=0;i<list2.size();i++){
							int a=(list2.get(i).getFinishTime()-list2.get(i).getStratTime());
							sn+=a;
							s[i]=list2.get(i).toString(ProcessStyle.all)+"       "+a ;
						}
						double averageA=sn/list2.size();
						double tn=0;
						for(int i=0;i<list2.size();i++){
							double t=(list2.get(i).getFinishTime()-list2.get(i).getStratTime())/list2.get(i).getServiceTime();
							tn+=t;
							s[i]+="        "+t ;
						}
						
						System.out.println("进程(开始时间，服务时间，优先级。运行时间，完成时间)      周转时间                                带权周转时间");
						for(int i=0;i<s.length;i++){
							System.out.println(s[i]);
						}
						System.out.println("平均周转时间："+sn/list2.size());
						System.out.println("平均带权周转时间："+tn/list2.size());
					}
					
					
				}else {
					System.out.println("菜单命令未识别，请重新输入");
				}
				System.out.println("输出完成。。。。");
			}
			
		}
	}
	public  void main(String[] args) {
		List<Process> list=null;
		while(true){
			
			System.out.println("--------菜单--------");
			System.out.println("‘IN’:输入。       ‘RUN’:运行      QUIT:退出");
			String menu=cin.next();
			if("IN".equals(menu.toUpperCase())){
				list=scanf();
			}else if ("RUN".equals(menu.toUpperCase())) {
				printf(list);
			}else if("QUIT".equals(menu.toUpperCase())){
				break;
			}else {
				System.out.println("菜单命令未识别，请重新输入");
				System.out.println("--------菜单--------");
				System.out.println("‘IN’:输入。       ‘RUN’:运行      QUIT:退出");
			}
		}
		System.out.println("欢迎下次使用调度算法演示程序");
	}

	public Scanner getCin() {
		return cin;
	}

	public void setCin(Scanner cin) {
		this.cin = cin;
	}
	
}