taskattemper.java

Java程序模拟操作系统中先进先出、短作业优先、响应比高者优先的作业调度

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Vector;

import javax.swing.*;
import javax.swing.table.*;
public class taskAttemper implements ActionListener {
	//一些变量的声明
	private Vector<Element> eleVector = new Vector<Element>();
	private JButton jbr,jbm,jbl;
	private DefaultTableModel jtData;
	private DefaultTableModel jtarData,jtamData,jtalData;
	
	/*入口函数*/
	public static void main(String[] args){
		new taskAttemper();
	}
	/*构造方法*/
	public taskAttemper(){
		create();
	}
	
	/*创建UI界面 并对按钮添加事件*/
	private void create(){	
		JPanel paneldwr = new JPanel();
		paneldwr.setLayout(new BorderLayout());
		jbr = new JButton("先来先服务");
		String[] jtaCNames = {"作业名","开始时间","完成时间", "周转时间","带权周转时间"};
		jtarData = new DefaultTableModel(jtaCNames,14); 
		JTable jtar = new JTable(jtarData);
		paneldwr.add(jbr,BorderLayout.NORTH);
		paneldwr.add(new JScrollPane(jtar),BorderLayout.CENTER);
		
		JPanel paneldwm = new JPanel();
		paneldwm.setLayout(new BorderLayout());
		jbm = new JButton("短作业优先");
		jtamData = new DefaultTableModel(jtaCNames,14); 
		JTable jtam = new JTable(jtamData);
		paneldwm.add(jbm,BorderLayout.NORTH);
		paneldwm.add(new JScrollPane(jtam),BorderLayout.CENTER);
		
		JPanel paneldwl = new JPanel();
		paneldwl.setLayout(new BorderLayout());
		jbl = new JButton("响应比高者优先");
		jtalData = new DefaultTableModel(jtaCNames,14); 
		JTable jtal = new JTable(jtalData);
		paneldwl.add(jbl,BorderLayout.NORTH);
		paneldwl.add(new JScrollPane(jtal),BorderLayout.CENTER);
		
		JPanel paneldw = new JPanel();
		paneldw.setLayout(new GridLayout(1,3));
		paneldw.add(paneldwr);
		paneldw.add(paneldwm);
		paneldw.add(paneldwl);
		
		String[] columnNames = {"作业名", "到达时间", "服务时间"};
		Object[][] rowData = {{"A",0,4},{"B",1,3},{"C",2,5},{"D",3,2},{"E",4,4}};
		jtData = new DefaultTableModel(rowData,columnNames); 
		jtData.setRowCount(16);
		JPanel panelup = new JPanel();
		panelup.setLayout(new GridLayout());
		JTable jt = new JTable(jtData);
		panelup.add(new JScrollPane(jt));
		
		JFrame frame = new JFrame();
		frame.setTitle("作业调度");
		frame.setLayout(new GridLayout(2,1));
		frame.add(panelup);
		frame.add(paneldw);		
		
		jbr.addActionListener(this);
		jbl.addActionListener(this);
		jbm.addActionListener(this);
		frame.setSize(800, 600);
		frame.setVisible(true);
	}
	
	//获得table中的数据 保存在eleVector中
	private void getData(){
		eleVector.clear();
		for(int i = 0;i < jtData.getRowCount();i++){
			if(jtData.getValueAt(i,0) != null){
				eleVector.add(new Element(jtData.getValueAt(i,0).toString(),
					Double.parseDouble(jtData.getValueAt(i,1).toString()),
						Double.parseDouble(jtData.getValueAt(i,2).toString())
						));
			}
		}
	}
	
	//对事件的响应
//	@Override
	public void actionPerformed(ActionEvent e) {
		// TODO Auto-generated method stub
		if(e.getSource() == jbr){//如果按下的是“先来先服务”按钮
			FCFS();
		}else if(e.getSource() == jbm){//如果按下的是“短作业优先”按钮
			SJF();
		}else if(e.getSource() == jbl){//如果按下的是“响应比高者优先”按钮
			HRESP();
		}
	}
	
	//对 先来先服务 事件进行处理  
	private void FCFS(){
		getData();
		Vector<Element> FCFSVector = new Vector<Element>();
		FCFSVector = eleVector;
		int elenum = FCFSVector.size();
		
		//每个进程对象按到达时间进行升序排序
		for(int i = 0;i<elenum;i++){
			for(int j = i;j<elenum-1;j++){
				if(FCFSVector.get(j).getArrive_time() > FCFSVector.get(j+1).getArrive_time()){
					Element temp = new Element( FCFSVector.get(j+1));
					FCFSVector.get(j+1).Change(FCFSVector.get(j));
					FCFSVector.get(j).Change(temp);
				}
			}			
		}
		
		//依次设置每个进程对象的 "开始时间","完成时间", "周转时间","带权周转时间" 并将其输出到相应表格中
		for(int k = 0;k<elenum;k++){
			if(k ==0){
				FCFSVector.get(k).setFinish_time(FCFSVector.get(k).getServes_time());
				FCFSVector.get(k).setAri_time(FCFSVector.get(k).getServes_time());
				FCFSVector.get(k).setDari_time(1);
			}else{
				FCFSVector.get(k).setStart_time(FCFSVector.get(k - 1).getFinish_time());
				FCFSVector.get(k).setFinish_time(FCFSVector.get(k).getServes_time() + FCFSVector.get(k - 1).getFinish_time());
				FCFSVector.get(k).setAri_time(FCFSVector.get(k).getFinish_time() - FCFSVector.get(k).getArrive_time());
				FCFSVector.get(k).setDari_time(FCFSVector.get(k).getAri_time()/FCFSVector.get(k).getServes_time());
			}
			jtarData.setValueAt(FCFSVector.get(k).getName(),k,0);
			jtarData.setValueAt(FCFSVector.get(k).getStart_time(),k,1);
			jtarData.setValueAt(FCFSVector.get(k).getFinish_time(),k,2);
			jtarData.setValueAt(FCFSVector.get(k).getAri_time(),k,3);
			jtarData.setValueAt(FCFSVector.get(k).getDari_time(),k,4);
		}
		
	}
	
	//对 短作业优先 事件进行处理  
	private void SJF() {
		// TODO Auto-generated method stub
		getData();
		Vector<Element> SJFVector = new Vector<Element>();
		SJFVector = eleVector;
		int elenum = SJFVector.size();
		
		//每个进程对象按服务时间进行升序排序
		for(int i = 0;i<elenum;i++){
			for(int j = 0;j<elenum - i -1;j++){
				if(SJFVector.get(j).getServes_time() > SJFVector.get(j+1).getServes_time()){
					Element temp = new Element( SJFVector.get(j+1));
					SJFVector.get(j+1).Change(SJFVector.get(j));
					SJFVector.get(j).Change(temp);
				}
			}
			
		}
		
		//以时间递增的方式 从排序后的向量中从前往后遍历  挨个输出第一次碰到的符合条件的进程
		int finish_num = 0;
		double current_time = 0;
		boolean ishave = false;
		while(finish_num < elenum){
			for(int i = 0;i<elenum;i++){
				if(current_time >= SJFVector.get(i).getArrive_time() && SJFVector.get(i).getFinish_time() == 0){
					SJFVector.get(i).setStart_time(current_time);
					SJFVector.get(i).setFinish_time(SJFVector.get(i).getServes_time() + current_time);
					SJFVector.get(i).setAri_time(SJFVector.get(i).getFinish_time() - SJFVector.get(i).getArrive_time());
					SJFVector.get(i).setDari_time(SJFVector.get(i).getAri_time()/SJFVector.get(i).getServes_time());
					current_time += SJFVector.get(i).getServes_time();
					ishave = true;
					jtamData.setValueAt(SJFVector.get(i).getName(),finish_num,0);
					jtamData.setValueAt(SJFVector.get(i).getStart_time(),finish_num,1);
					jtamData.setValueAt(SJFVector.get(i).getFinish_time(),finish_num,2);
					jtamData.setValueAt(SJFVector.get(i).getAri_time(),finish_num,3);
					jtamData.setValueAt(SJFVector.get(i).getDari_time(),finish_num,4);
					finish_num++;
					break;
				}
			}
			if(ishave == true){
				ishave = false;
			}else{
				//增加时间到剩下进程的到达时间中的最小值
				for(int i = 0;i<elenum;i++){
					if(SJFVector.get(i).getFinish_time() == 0){
						current_time = SJFVector.get(i).getArrive_time();
						break;
					}
				}
				for(int j = 0;j<elenum;j++){
					if(current_time > SJFVector.get(j).getArrive_time() && SJFVector.get(j).getFinish_time() == 0){
						current_time = SJFVector.get(j).getArrive_time();
					}
				}
			}
		}
	}
	
	//对 响应比高者优先 事件进行处理
	private void HRESP() {
		// TODO Auto-generated method stub
		getData();
		Vector<Element> HRESPVector = new Vector<Element>();
		HRESPVector = eleVector;
		
		//以时间递增的方式 挨个取得某一时刻优先权最大的经常 并让其执行
		int elenum = HRESPVector.size();
		double current_time = 0;
		int finish_num = 0;
		while(finish_num < elenum){
			int eleIndex = 0;
			double Rp = 0;
			for(int i = 0;i<elenum;i++){
				if(HRESPVector.get(i).getFinish_time() == 0 && Rp < getRp(HRESPVector.get(i),current_time)){
					Rp = getRp(HRESPVector.get(i),current_time);
					eleIndex  = i;
				}
			}
			if(Rp >= 1){
				HRESPVector.get(eleIndex).setStart_time(current_time);
				HRESPVector.get(eleIndex).setFinish_time(HRESPVector.get(eleIndex).getServes_time() + current_time);
				HRESPVector.get(eleIndex).setAri_time(HRESPVector.get(eleIndex).getFinish_time() - HRESPVector.get(eleIndex).getArrive_time());
				HRESPVector.get(eleIndex).setDari_time(HRESPVector.get(eleIndex).getAri_time()/HRESPVector.get(eleIndex).getServes_time());
				current_time += HRESPVector.get(eleIndex).getServes_time();
				
				jtalData.setValueAt(HRESPVector.get(eleIndex).getName(),finish_num,0);
				jtalData.setValueAt(HRESPVector.get(eleIndex).getStart_time(),finish_num,1);
				jtalData.setValueAt(HRESPVector.get(eleIndex).getFinish_time(),finish_num,2);
				jtalData.setValueAt(HRESPVector.get(eleIndex).getAri_time(),finish_num,3);
				jtalData.setValueAt(HRESPVector.get(eleIndex).getDari_time(),finish_num,4);
				
				finish_num++;
			}else{
				//增加时间到剩下进程的到达时间中的最小值
				for(int i = 0;i<elenum;i++){
					if(HRESPVector.get(i).getFinish_time() == 0){
						current_time = HRESPVector.get(i).getArrive_time();
						break;
					}
				}
				for(int j = 0;j<elenum;j++){
					if(current_time > HRESPVector.get(j).getArrive_time() && HRESPVector.get(j).getFinish_time() == 0){
						current_time = HRESPVector.get(j).getArrive_time();
					}
				}
			}
		}
	}
	
	//获得某时刻该进程的优先权
	private double getRp(Element ele,double current_time){
		if(current_time >= ele.getArrive_time()){
			double Rp = (ele.getServes_time() + current_time - ele.getArrive_time())/ele.getServes_time();
			return Rp;
		}else{
			return 0;
		}
	}
}

/*创建一个进程类，以后对每一个进程都可以用对象来处理*/
class Element{
	private String name;
	private double arrive_time;
	private double serves_time;
	private double start_time;
	private double finish_time;
	private double ari_time;
	private double dari_time;
	
	/*构造方法*/
	public Element(Element ele){
		this.name = ele.getName();
		this.arrive_time = ele.getArrive_time();
		this.serves_time = ele.getServes_time();
		this.start_time = 0;
		this.finish_time = 0;
		this.ari_time = 0;
		this.dari_time = 0;
	}
	/*构造方法*/
	public Element(String name,double arrive_time,double serves_time){
		this.name = name;
		this.arrive_time = arrive_time;
		this.serves_time = serves_time;
		this.start_time = 0;
		this.finish_time = 0;
		this.ari_time = 0;
		this.dari_time = 0;
	}
	public void Change(Element ele){
		this.name = ele.getName();
		this.arrive_time = ele.getArrive_time();
		this.serves_time = ele.getServes_time();
		this.start_time = 0;
		this.finish_time = 0;
		this.ari_time = 0;
		this.dari_time = 0;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getArrive_time() {
		return arrive_time;
	}
	public void setArrive_time(double arrive_time) {
		this.arrive_time = arrive_time;
	}
	public double getServes_time() {
		return serves_time;
	}
	public void setServes_time(double serves_time) {
		this.serves_time = serves_time;
	}
	public double getStart_time() {
		return start_time;
	}
	public void setStart_time(double start_time) {
		this.start_time = start_time;
	}
	public double getFinish_time() {
		return finish_time;
	}
	public void setFinish_time(double finish_time) {
		this.finish_time = finish_time;
	}
	public double getAri_time() {
		return ari_time;
	}
	public void setAri_time(double ari_time) {
		this.ari_time = ari_time;
	}
	public double getDari_time() {
		return dari_time;
	}
	public void setDari_time(double dari_time) {
		this.dari_time = dari_time;
	}
}