进程调度程序设计之简单轮转法的java实现

        设计一个有几个进程共行的进程调度程序，每个进程由一个进程控制块(PCB)表示，进程控制块通常应包括下述信息：进程名，进程优先数，进程需要运行的时间，占用CPU的时间以及进程的状态等，且可按照调度算法的不同而增删。
        系统应能显示或打印各进程状态和参数的变化情况，便于观察。
        本程序使用简单轮转法对进程进行调度。每个进程处于运行R(run)、就绪W(wait)和完成F(finish)三种状态之一， 并假定起始状态都是就绪状态W。
        为了便于处理，程序中进程的运行时间以时间片为单位计算。各进程的优先数或轮转时间片数、以及进程需要运行的时间片数，均由伪随机数发生器产生。

        进程就绪链按各进程进入的先后次序排列，进程每次占用处理机的轮转时间按其重要程度登入进程控制块中的轮转时间片数记录项（相应于优先数法的优先数记录项位置）。每过一个时间片，运行进程占用处理机的时间片数加1，然后比较占用处理机的时间片数是否与该进程的轮转时间片数相等，若相等说明已到达轮转时间，应将现运行进程排到就绪链末尾，调度链首进程占用处理机，且改变它们的进程状态，直至所有进程完成各自的时间片。

进程控制块结构如下： 

进程控制块链结构如下：

程序框图如下图所示（右边）：

主类

package report;

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

public class N2 {
	// cpu总工作时间
	private static int allTime;
	// 一个时间片
	private static int pieceTime = 1;
	// current
	private static Pcb currentPcb;
	// wait链
	private static List<Pcb> waitList = new ArrayList<Pcb>();
	// finish链
	private static List<Pcb> finishList = new ArrayList<Pcb>();

	public static void main(String[] args) {
		// 初始化wait链
		Pcb Pcb1 = new Pcb(1, (int) (Math.random() * 10 + 1), (int) (Math.random() * 10 + 1), 0, "wait");
		Pcb Pcb2 = new Pcb(2, (int) (Math.random() * 10 + 1), (int) (Math.random() * 10 + 1), 0, "wait");
		Pcb Pcb3 = new Pcb(3, (int) (Math.random() * 10 + 1), (int) (Math.random() * 10 + 1), 0, "wait");
		Pcb Pcb4 = new Pcb(4, (int) (Math.random() * 10 + 1), (int) (Math.random() * 10 + 1), 0, "wait");
		Pcb Pcb5 = new Pcb(5, (int) (Math.random() * 10 + 1), (int) (Math.random() * 10 + 1), 0, "wait");

		waitList.add(Pcb1);
		waitList.add(Pcb2);
		waitList.add(Pcb3);
		waitList.add(Pcb4);
		waitList.add(Pcb5);

	

		roundRobin();
	}

	

	private static void roundRobin() {

		while (!waitList.isEmpty()) {
			// 链首进程投入运行，将链首进程移出链
			currentPcb = waitList.get(0);
			waitList.remove(0);
			currentPcb.setStatus("【run】");
			while (currentPcb.getNeedTime() > 0) {
				// 开始时间片
				costPieceTimeInRoundRobin();
				// 时间片结束
				if (currentPcb.getNeedTime() == 0) {
					// 撤销该进程，设置status为finish，放到finish链
					currentPcb.setStatus("finish");
					finishList.add(currentPcb);
					break;
				} else {

					if (!waitList.isEmpty()) {
						// 占用处理机时间片没到
						if (currentPcb.getPriority() > currentPcb.getCostTime()) {
							continue;
						} else {
							// 撤销该进程，设置status为wait，放到wait链尾
							currentPcb.setStatus("wait");
							waitList.add(currentPcb);
							System.out.println("\n备注：进程" + currentPcb.getId() + "占用处理机时间片到，故重新插到wait链尾\n");
							break;
						}
					}

					else {
						continue;
					}
				}
			}
		}
		printFinishList();

	}

	private static void printAllLists() {
		System.out.println("id\t    needTime\t    priority\t    costTime\t       status\n");
		// finish链
		for (Pcb pcb : finishList)
			System.out.println(pcb.getId() + "\t\t" + pcb.getNeedTime() + "\t\t" + pcb.getPriority() + "\t\t"
					+ pcb.getCostTime() + "\t\t" + pcb.getStatus());
		// current
		System.out.println(currentPcb.getId() + "\t\t" + currentPcb.getNeedTime() + "\t\t" + currentPcb.getPriority()
				+ "\t\t" + currentPcb.getCostTime() + "\t\t" + currentPcb.getStatus());
		// wait链
		for (Pcb pcb : waitList)
			System.out.println(pcb.getId() + "\t\t" + pcb.getNeedTime() + "\t\t" + pcb.getPriority() + "\t\t"
					+ pcb.getCostTime() + "\t\t" + pcb.getStatus());
		System.out.println(
				"==========================================================================allTime:" + allTime);
	}

	private static void printFinishList() {
		System.out.println("id\t    needTime\t    priority\t    costTime\t       status\n");
		// finish链
		for (Pcb pcb : finishList)
			System.out.println(pcb.getId() + "\t\t" + pcb.getNeedTime() + "\t\t" + pcb.getPriority() + "\t\t"
					+ pcb.getCostTime() + "\t\t" + pcb.getStatus());
		System.out.println(
				"==========================================================================allTime:" + allTime);
	}


	private static void costPieceTimeInRoundRobin() {
		printAllLists();
		// 开始一个时间片
		try {
			Thread.sleep(pieceTime);
		} catch (InterruptedException e) {

		}
		// 时间片到，当前进程需要时间片数-1
		int currentPcbNeedTime = currentPcb.getNeedTime() - 1;
		currentPcb.setNeedTime(currentPcbNeedTime);

		// 时间片到，当前进程占用片数+1
		int currentPcbCostTime = currentPcb.getCostTime() + 1;
		currentPcb.setCostTime(currentPcbCostTime);
		// 时间片到，cpu总工作时间+1
		allTime++;

	}
}

pcb类

package report;

public class Pcb implements Comparable<Object> {

	private int id;
	private int priority;
	private int needTime;
	private int costTime;
	private String status;

	Pcb(int id, int priority, int needTime, int costTime, String status) {
		this.id = id;
		this.priority = priority;
		this.costTime = costTime;
		this.needTime = needTime;
		this.status = status;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public int getPriority() {
		return priority;
	}

	public void setPriority(int priority) {
		this.priority = priority;
	}

	public int getCostTime() {
		return costTime;
	}

	public void setCostTime(int costTime) {
		this.costTime = costTime;
	}

	public int getNeedTime() {
		return needTime;
	}

	public void setNeedTime(int needTime) {
		this.needTime = needTime;
	}

	public String getStatus() {
		return status;
	}

	public void setStatus(String status) {
		this.status = status;
	}

	@Override
	public int compareTo(Object o) {
		Pcb s = (Pcb) o;
		if (this.getPriority() <= s.getPriority())
			return 1;
		else
			return -1;

	}

}

运行过程部分截图