java 实现 操作系统中得进程调度 短作业优先和时间片算法

 

时间片的实现过程

 package com.xiangongyedaxue.OS;

import java.util.Iterator;
import java.util.LinkedList;

import javax.swing.JOptionPane;

import com.xiangongyedaxue.OS.util.RRname;

/*
 * 时间片轮转算法： 1. 系统将所有进程按照先来先服务的原则进行排序， 每次调度分配给首进程，并执行一个时间片 ；
 * 2.执行完时间片，如果该进程小于时间片，输出；并将该进程放入LinkedList的队首 3.
 * 同时，查找执行总时间内是否有进程到达？如果有到达，执行到达进程，转至2； 4.
 * 执行linkedList的首进程，如果进程服务时间小于时间片，输出；如果大于，将首进程加入到LinkedList尾，移除首进程
 */
public class RoundRobin
{
	String str[] =
	{
			"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",
			"N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"
	};// 用于标记进程号码
	LinkedList<RRname> list = new LinkedList<RRname>();// 用来存放未一次执行完毕的进程

	/*
	 * 将String转化为Int 目的： 将输入的变量转换成字符数组
	 */
	public int[] StringtoInt(String string[])
	{
		int a[] = null;
		a = new int[string.length];
		for (int i = 0; i < string.length; i++)
		{
			int temp = Integer.parseInt(string[i]);
			a[i] = (int) temp;
		}
		return a;
	}

	public void init()
	{

		int pronum;
		int timepic;// 分别用于记录进程进入数目和时间片大小
		RRname rr[] = null; // 用于为进程创建数组
		int Prointime[] = null;
		int ProSertime[] = null;
		pronum = Integer.parseInt(JOptionPane.showInputDialog("请输入进程数目"));
		timepic = Integer.parseInt(JOptionPane.showInputDialog("请输入时间片"));
		String proIntime = JOptionPane
				.showInputDialog("分别输入进程的进入时间：格式为：（XX,XX,XX）");
		String proServicetime = JOptionPane
				.showInputDialog("分别输入进程的服务时间：格式为：（XX,XX,XX）");
		rr = new RRname[pronum];
		System.out.println(rr.length);
		for (int i = 0; i < pronum; i++)
		{
			rr[i] = new RRname();
			String prointime[] = proIntime.split(",");
			String proservicetime[] = proServicetime.split(",");// 以","为分隔条件
			Prointime = new int[prointime.length];
			ProSertime = new int[proservicetime.length];
			Prointime = StringtoInt(prointime);// 进程进入时间数组
			ProSertime = StringtoInt(proservicetime);// 进程服务时间数组
			rr[i].setInname(Prointime[i]);
			rr[i].setProTime(ProSertime[i]);
			rr[i].setProname(str[i]);
		}
		for (int j = 0; j < pronum; j++)// 辅助显示功能--以上代码只是用于实现了将进程初始条件成功赋值
		{
			System.out.println(rr[j].toString());
		}
		Linkpro(rr, timepic, pronum);
		System.out.println("时间片" + timepic);
		float evequan = 0;
		float eveRound = 0;
		for (int j = 0; j < pronum; j++)// 辅助显示功能--以上代码只是用于实现了将进程初始条件成功完成后的结果
		{
			evequan += rr[j].getRoundTimer() / rr[j].getKeepservice();
			eveRound += rr[j].getRoundTimer();
			System.out.println(rr[j].toString1());
		}
		System.out.println("平均周转时间为" + eveRound / pronum + "带权周转时间为：" + evequan
				/ pronum);
	}

	/*
	 * 目的：实现连接的作用以及进行必要的处理： 输入参数：RRname[]:各个进程的初始化条件 timepic:时间片 pronum:进程数目
	 */
	public void Linkpro(RRname rname[], int timepic, int pronum)
	{
		int count = 0;
		int i = 0;
		for (int j = 0; j < rname.length; j++)// 用于保存服务时间
		{
			rname[j].setKeepservice(rname[j].getProTime());

		}
		excPro(rname, i, timepic, count, pronum);
	}

	/*
	 * 目的：将所有进程依照进入时间进行排序 输入变量：RRname[]:各个进程的初始状态
	 */
	public void find_Pro1(RRname fl[])// OK
	{
		RRname na = null;
		na = new RRname();
		int temp = -1;
		for (int i = 0; i < fl.length; i++)
		{
			for (int j = i + 1; j < fl.length; j++)
			{

				if (fl[i].getInname() > fl[j].getInname())
				{
					na = fl[i];
					fl[i] = fl[j];
					fl[j] = na;
					temp = j;
				}
			}
		}

	}

	/*
	 * 目的：
	 * 
	 */

	public void excPro(RRname r[], int i, int timepic, int count, int pronum)
	{
		int coun = 0;// 计数器
		find_Pro1(r); // 按进入时间大小排序
		for (int j = 0; j < r.length; j++)
		{
			coun = exqTimepic(r[j], timepic, coun);
			if (r[j].getProTime() <= 0)// OK----进程小于时间片
			{
				// System.out.println(r[j].toString());
				// System.out.println(j + "****@@@" + coun);
			}
			else//进程大于时间片
			{
				list.addLast(r[j]);// 将执行完的进程放入队列尾部
				// System.out.println("size:"+list.size());
				if (list.size() > 1)//排除linkedList只有一个的情况
				{ // 队列中存在进程

					coun = exqTimepic(list.getFirst(), timepic, coun);//找到首进程  ，执行
					if (list.getFirst().getProTime() == -1) //执行完
					{// 进程结束
						// System.out.println(list.getFirst().toString());
						list.remove(list.getFirst());//从队列中移除
					}
					else
					{    

						// System.out.println(list.getFirst().toString());
						// System.out.println("(*******)");
						RRname na = list.getFirst();
						list.remove();
                       list.addLast(na);//将进程放入队尾
                      }
					continue;
				}
				continue;
			}

		}//
		// System.out.println("(*******)"+list.size());
		
		while (list.size() > 0)//队列中还有进程，执行完毕
		{
			coun = exqTimepic(list.getFirst(), timepic, coun);
			if (list.getFirst().getProTime() == -1)
			{// 进程结束
				// System.out.println(list.getFirst().toString());
				list.remove(list.getFirst());

			}
			else
			{
			    RRname na = list.getFirst();
				list.remove();
				list.addLast(na);
			}
			continue;
		}

	}

	/*
	 * 將所有进程按照时间片执行 输入参数：RRname:找到的进程 timepic:时间片 count:未完成此进程的总时间
	 * 输出参数：完成此进程后的总时间
	 */
	public int exqTimepic(RRname proser, int timepic, int count)
	{

		if (timepic >= proser.getProTime())// 在时间片大于或等于进程的进入时间的同时并且时间片大于或等于该进程的服务时间
		{
			if (proser.getInname() > count)// 说明可能是第一次到达进程，也可能是进入时间太大
											// count将被重新赋值
			{
				proser.setResult(proser.getProTime() + proser.getInname());
				count = proser.getInname() + proser.getProTime();// 说明count已经变为新值
			}
			else
			{
				proser.setResult(proser.getProTime() + count);
				count = count + proser.getProTime();// 说明count已经变为新值

			}
			proser.setProTime(-1);// 标记进程已经被访问
		}
		else
		{// 将会在访问

			proser.setResult(count + timepic);
			proser.setProTime(proser.getProTime() - timepic);
			count = count + timepic;
		}
		return count;
	}

}

想请前辈们指点下，此代码在格式上和思路上存在什么不足？请大侠指点   

 

评论

2 楼 qweer521775 2012-09-05  

/*RR时间片轮转调度算法*/
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class RR extends JFrame implements ActionListener,Runnable{
	Thread myThread;
	JPanel p1=new JPanel();      /*就绪*/
	JPanel p2=new JPanel();      /*控制台*/
	JPanel p3=new JPanel();      /*完成*/
	JPanel p4=new JPanel();      /*左边*/
	JButton []b=new JButton[10]; /*就绪队列*/
	JButton []d=new JButton[10]; /*完成队列*/
	JButton jbBegin,jbAdd,jbSuspend;
	
	public int [][]pcb=new int [10][5]; /*最多10个进程。存放进程信息：第一列表示所需时间片，第二列表示已执行与否，第三列表示剩下的时间片，第四列表示到达时间，第五列进程ID*/
	public final static int pT=20;		/*单位时间片长度  Piece of Time*/
	public int curTime=0;               /*作为程序运行时的时间*/
	public int pcbCount=0;              /*进程数量，最多10个进程*/	
	boolean Continue=false;             /*开始执行标志*/
	boolean Susp=false;                 /*增加进程标志*/
	public RR(){
		/*线程*/
		myThread=new Thread(this);	
		myThread.start();		
		/*程序窗口初始化*/
		JFrame f=new JFrame();
		f.setTitle("时间片轮转调度算法（RR）");
		f.setSize(650,450);
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.setVisible(true);		
		f.setLayout(new GridLayout(1,2));
		/*进程信息初始化*/
		for(int i=0;i<10;i++){
				pcb[i][1]=0;         /*无进程，不显示*/
				b[i]=new JButton();			
		}		
		p1.setVisible(true);
		p1.setLayout(new GridLayout(10,1));
		for(int i=0;i<10;i++)
			p1.add(b[i]);		
		/*初始化“添加进程”和“开始”按钮*/
		jbBegin=new JButton("         开始         ");
		jbAdd=new JButton("        添加进程        ");
		jbSuspend=new JButton("        阻塞        ");
		p2.setVisible(true);
		p2.setLayout(new GridLayout(3,1));
		p2.add(jbBegin);
		p2.add(jbAdd);
		p2.add(jbSuspend);
		f.add(p1);
		f.add(p2);
		/*添加事件监听*/
		jbBegin.addActionListener(this);
		jbAdd.addActionListener(this);
		jbSuspend.addActionListener(this);
	}	
	public void actionPerformed(ActionEvent e){
		if (e.getSource() == jbBegin){
			if(Continue==false)
				Continue=true;
		}
		if (e.getSource() == jbAdd){
			if(pcbCount<10){
				int tNeed=(int)(Math.random()*100);
				pcb[pcbCount][0]=tNeed;
				pcb[pcbCount][1]=1;
				pcb[pcbCount][2]=tNeed;
				pcb[pcbCount][3]=curTime;
				pcb[pcbCount][4]=pcbCount+1;
				b[pcbCount].setText(" 进程"+(pcbCount+1)+" 到达时间"+curTime+"  需要时间"+tNeed+" ");
				pcbCount++;
				curTime++;				
			}
		}
		if (e.getSource() == jbSuspend){
			Susp=true;
		}
	}	
	public void run(){
		while(true){
			if(Continue==true){
				int select=0;								
				//选出最先到达的进程，冒泡排序
				for(int i=0;i<pcbCount;i++){
					for(int j=0;j<pcbCount-i-1;j++){
						if(pcb[j][3]>pcb[j+1][3]){
							int temp[]=pcb[j];
							pcb[j]=pcb[j+1];
							pcb[j+1]=temp;
						}
					}
				}
				//重新显示就绪队列
				for(int j=0;j<10;j++){
					if(pcb[j][1]==1)
						b[j].setText(" 进程"+(pcb[j][4])+" 到达时间"+pcb[j][3]+"  需要时间"+pcb[j][0]+" "+"  剩余时间"+pcb[j][2]);
					if(pcb[j][1]==2)
						b[j].setText(" 进程"+(pcb[j][4])+"  执行完毕");
				}
				/*已执行的进程不能再执行，置select 为-1作为标志*/
				if(pcb[0][1]==2)
					select=-1;
				//被选中而开始执行的进程，则不再在队列中显示，把显示标记置1
				else
					pcb[0][1]=1;					
				//放到开始按钮（CPU）上显示
				if(select!=-1){
					for(int j=1;j<=pT;j++){
						if(Susp==true){
							jbBegin.setText("处理I/O请求，"+"进程"+(pcb[0][4])+" 阻塞");
							try{
								Thread.sleep(8888);
							}catch(InterruptedException e){};
							Susp=false;
							break;
						}
						else{
							curTime++;
							if(pcb[0][2]>=0)
								jbBegin.setText("进程"+(pcb[0][4])+" 需要时间"+pcb[0][0]+" 正在执行: "+pcb[0][2]--);
							else
								break;
							try{
								Thread.sleep(100);
							}catch(InterruptedException e){};
						}
					}
					pcb[0][3]=curTime;
				}
				/*如果已经执行完*/
				if(pcb[0][2]<0){
					pcb[0][1]=2;
					pcb[0][3]=1000000;
				}				
									
			}
		}
	}
	
	public static void main(String []args){
		new RR();
	}
}

1 楼 波风水门 2012-05-01  

com.xiangongyedaxue.OS.util.RRname的代码可以提供下吗，谢谢