设计一个按照优先级调度算法实现处理机调度的程序

( 1 ) 假设系统有n个进程，每个进程用一个进程控制块（PCB）来代表。进程控制块的格式如下表所示，且参数意义也相同。进程的优先数、到达时间和估计运行时间由用户程序任意设定，且优先数越低，优先级越高。调度时，总是选择优先级最高的进程运行。
（2）为了调度方便，设计一个指针指向就绪队列的第一个到达进程。另外再设一个当前运行进程指针，指向当前正运行的进程。
（3）处理机调度时，总是选择已经到达队列的优先级最高的进程运行。为了采用动态优先级调度，进程每运行一次，其优先级就减1。
（4）由于本题目是模拟实验，所以对被选中的进程并不实际启动运行，而只是执行如下操作：
1）优先数加1；
2）估计运行时间减1；
3）输出当前运行进程的名字。
用这三个操作来模拟进程的一次运行。
（5）进程运行一次后，应判断该进程的剩余运行时间是否为0，若不为0，且其优先级低于就绪队列的其他进程的优先级，则选择一个高优先级进程抢占CPU运行，若该进程的剩余运行时间为0，则将该进程的状态置为完成状态“C”，并撤出就绪队列。
（6）若就绪队列不为空，则重复上述的步骤（4）和（5）直到所有进程都运行完为止。
（7）在所设计的调度程序中，应包含显示或打印语句，以便显示或打印每次选中进程的名称及运行一次后进程的变化以及就绪队列中各进程排队情况。

模拟PCB进程控制块设置了如上数据结构，其中name是进程名，arrivalTime是到达时间，priorityNum是优先级数，runTime是运行时间，status是进程状态。
其中：
name为用户程序自定义的
priorityNum为1~10的随机数
arrivalTime和runTime为1~5的随机数
status的值有三种：Ready，Working，End，分别代表就绪状态，运行状态和终止状态。

PCB类：

package pcb;

public class PCB {
	private String name;//进程名字
	private int arrivalTime;//到达时间,1~5的随机数
	private int priorityNum;//优先级，1~10的随机数
	private int runTime;//运行时间，1~5的随机数
	private String status = "Ready";//进程状态

	public PCB(String name) {
		super();
		this.name = name;
		this.setArrivalTime(arrivalTime);
		this.setPriorityNum(priorityNum);
		this.setRunTime(runTime);
		//this.printInformation();	
	}
	
	//打印PCB信息
	public void printInformation() {
		System.out.println(this.getName()+"t"+this.getArrivalTime()+"t"+
				this.getRunTime()+"t"+this.getPriorityNum()+"t"+this.getStatus());
	}

	

//	public PCB(String name, int arrivalTime, int priorityNum, int runTime) {
//	super();
//	this.name = name;
//	this.arrivalTime = arrivalTime;
//	this.priorityNum = priorityNum;
//	this.runTime = runTime;
//	this.printInformation();
//}



	//进程运行
	public void run() {		
		this.priorityNum++;
		this.runTime--;		
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getArrivalTime() {
		return arrivalTime;
	}

	public void setArrivalTime(int arrivalTime) {
		arrivalTime = (int) (Math.random()*5+1);
		this.arrivalTime = arrivalTime;
	}

	public int getPriorityNum() {
		return priorityNum;
	}

	public void setPriorityNum(int priorityNum) {
		priorityNum = (int) (Math.random()*10+1);
		this.priorityNum = priorityNum;
	}

	public int getRunTime() {
		return runTime;
	}

	public void setRunTime(int runTime) {
		runTime = (int) (Math.random()*5+1);
		this.runTime = runTime;
	}

	public String getStatus() {
		return status;
	}

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

Priority 类：

package pcb;

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

public class Priority {
	public static void getMax(Queue<PCB> queue) {
		//找出优先级最高（优先级数最小）的进程
		int minPriorityNum = 100;
		int minArrivalTime = 100;
		for(PCB q : queue ) {
			if(q.getPriorityNum() < minPriorityNum) {
				minPriorityNum = q.getPriorityNum();	
			}			
		}
		//找出优先级最高且到达时间最早的进程
		for(PCB q : queue ) {
			if(q.getPriorityNum() == minPriorityNum && q.getArrivalTime() < minArrivalTime) {
				minArrivalTime = q.getArrivalTime();
			}
		}
		
		PCB first = queue.peek();
		for(int i = 0;i < queue.size();i++) {
			while(queue.peek().getPriorityNum() > minPriorityNum) {
				queue.offer(queue.peek());
				queue.poll();			
			}
			PCB q =  ((LinkedList<PCB>) queue).get(i);
			
			if(!q.equals(first)) {				
				if((q.getPriorityNum() == queue.peek().getPriorityNum()) && q.getArrivalTime() < queue.peek().getArrivalTime()) {					
					while(queue.peek().getArrivalTime() != minArrivalTime) {
						queue.offer(queue.peek());
						queue.remove(queue.peek());
						queue.remove(0);
						//i--;
					}										
				}else {						
					continue;
				}				
			}else {
				continue;
			}
		}				
	}
	
	public static void main(String[] args) {
		System.out.println("名字t"+"到达时间t"+"运行时间t"+"优先级数t"+"状态");
		Queue<PCB> queue = new LinkedList<PCB>();
//		queue.offer(new PCB("a1",1,9,9));
//		queue.offer(new PCB("a2",2,5,10));	
//		queue.offer(new PCB("a3",5,7,10));
//		queue.offer(new PCB("a4",2,4,6));
		queue.offer(new PCB("a1"));
		queue.offer(new PCB("a2"));	
		queue.offer(new PCB("a3"));
//		queue.offer(new PCB("a4"));
//		queue.offer(new PCB("a5"));
//		queue.offer(new PCB("a6"));	
//		queue.offer(new PCB("a7"));
//		queue.offer(new PCB("a8"));
//		queue.offer(new PCB("a9"));
//		queue.offer(new PCB("a10"));	
//		queue.offer(new PCB("a11"));
//		queue.offer(new PCB("a12"));
//		queue.offer(new PCB("a13"));
//		queue.offer(new PCB("a14"));	
//		queue.offer(new PCB("a15"));
//		queue.offer(new PCB("a16"));
		
				
//		System.out.println("=======================================");
		
		while(!queue.isEmpty()) {
			//把优先级最高（优先级数小）的进程调到队首
			if(queue.size() > 1) {
				getMax(queue);			
			}
			
			if(!queue.isEmpty()) {
				//遍历队列，设置进程状态
				for(PCB q : queue) {
					if(q.equals(queue.peek())) {
						//队首
						q.setStatus("Working");
					}else {
						//非队首
						if(q.getStatus().equals("Working")) {
							q.setStatus("Ready");
						}												
					}
					//打印信息
					q.printInformation();
				}
				//进程运行
				queue.peek().run();
			}
			
			for(PCB q : queue) {
				if(q.getRunTime() == 0) {
					q.setStatus("End");					
				}
												
				if(q.getStatus().equals("End")) {
					System.out.println();
					//打印信息
					q.printInformation();
					System.out.print("==============="+q.getName()+"进程结束================");
					queue.poll();
					break;
				}			
			}			
			System.out.println();	
			}				
		}		
	}

1.第一次运行结果：

2.第二次运行结果：

本实验是模拟优先级调度算法实现处理机调度的程序，实验中假设所有创建的进程都已在内存中，即一个等待运行的队列中，每次都将优先级最高的进程放到队首，然后每运行一次进程就下降一个优先权再进行优先权比较 ，如果优先级相同则比较到达时间，将优先级最高且到达时间最早的进程放到队首。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。
本程序测试过程中加入了32个进程，程序运行稳定且结果正确，说明了程序的鲁棒性较好。