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;
	}

}

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