进程调度程序设计之优先数法的java实现

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

        进程就绪链按优先数大小从大到小排列，链首进程首先投入运行。每过一个时间片，运行进程所需运行的时间片数减1，说明它已运行了一个时间片，优先数也减3。理由是该进程如果在一个时间片中完成不了，优先级应降低一级。接着比较现行进程和就绪链链首进程的优先数，如果仍是现行进程高或者相同，就让现行进程继续运行，否则，调度就绪链链首进程投入运行。原运行进程再按其优先数大小插入就绪链，且改变它们对应的进程状态，直至所有进程都运行完各自的时间片数。

进程控制块结构如下： 

进程控制块链结构如下：

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

主类

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

		 priority();


	}

	private static void priority() {

		// 生成并按优先数大小排列进程控制块链

		Collections.sort(waitList);

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

				} else {

					if (!waitList.isEmpty()) {
						// 优先数大于链首进程
						if (currentPcb.getPriority() >= waitList.get(0).getPriority()) {
							continue;
						} else {
							// 撤销该进程，设置status为wait，按priority放到wait链中
							currentPcb.setStatus("wait");
							waitList.add(currentPcb);
							Collections.sort(waitList);
							System.out.println("\n备注：进程" + currentPcb.getId() + "的priority小于wait链首，故重新插入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 costPieceTimeInPriority() {
		printAllLists();
		// 开始一个时间片
		try {
			Thread.sleep(pieceTime);
		} catch (InterruptedException e) {

		}
		// 时间片到，当前进程需要时间片数-1
		int currentPcbNeedTime = currentPcb.getNeedTime() - 1;
		currentPcb.setNeedTime(currentPcbNeedTime);
		// 时间片到，当前进程优先数-3
		int currentPcbPriority = currentPcb.getPriority() - 3;
		currentPcb.setPriority(currentPcbPriority);
		// 时间片到，当前进程占用片数+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;

	}

}

运行过程部分截图