实验要求
设计一个按优先权调度算法实现处理器调度的程序。
【提示】
（1）假定系统有五个进程，每一个进程用一个进程控制块PCB来代表，进程控制块的格式为：
其中，
- 进程名——作为进程的标识，假设五个进程的进程名分别为P1，P2，P3，P4，P5。
- 指针——按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程中的指针为“0”。
- 要求运行时间——假设进程需要运行的单位时间数。
- 优先数——赋予进程的优先权，调度时总是选取优先数大的进程先执行。
- 状态——可假设有三种状态，“就绪”状态（ready）、“运行”状态（working）和“结束”状态（finish）。五个进程的初始状态都为“就绪”，用“R”表示；当进程运行结束后，它的状态为“结束”，用“E”表示；当进程被选中开始运行但尚未结束时，它的状态为“运行”，用“W”表示。
（2） 在每次运行你所设计的处理器调度程序之前，为每个进程任意确定它的“优先数”和“要求运行时间”。
（3）为了调度方便，把五个进程按给定的优先数从大到小连成队列。用一单元指出队首进程，用指针指出队列的连接情况。例：
队首标志
（4）处理器调度总是选队首进程运行。采用动态改变优先数的办法，进程每运行一次优先数就减“1”。由于本实验是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行：
优先数-1
要求运行时间-1
来模拟进程的一次运行。
提醒注意的是：在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行结束。在这里省去了这些工作。
（5）进程运行一次后，若要求运行时间不等于0，则再将它加入队列（按优先数大小插入，且置队首标志）；若要求运行时间等于0，则把它的状态修改成“结束”（E），且退出队列。
（6）若“就绪”状态的进程队列不为空，则重复上面（4）和（5）的步骤，直到所有进程都成为“结束”状态。
（7）在所设计的程序中应有显示或打印语句，能显示或打印每次被选中进程的进程名以及运行一次后进程队列的变化。
（8）为五个进程任意确定一组“优先数”和“要求运行时间”，启动所设计的处理器调度程序，显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。
实现代码（Java语言描述）
首先是PCB类：
/**
* PCB数据结构
* @author BlankSpace
*/
public class PCB {
/**
* PCB名称
*/
private String name;
/**
* 下一个PCB（是一个引用，也相当于一个指针）
*/
private String next;
/**
* 进程当前的优先级（可变）
*/
private int priority;
/**
* 进程运行所需最长时间
*/
private int needTime;
/**
* 进程状态
*/
private String state;
/**
* 周转时间
*/
private int roundTime;
/**
* 等待时间
*/
private int waitingTime;
/**
* 上一次执行的CPU时间
*/
private int lastTime;
public PCB(String name,int needTime,int priority, String state) {
this.name = name;
this.needTime = needTime;
this.priority = priority;
this.state = state;
this.next = null;
this.roundTime = 0;
this.waitingTime = 0;
this.lastTime = 0;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getNext() {
return next;
}
public void setNext(String next) {
this.next = next;
}
public int getPriority() {
return priority;
}
public void setPriority(int priority) {
this.priority = priority;
}
public int getNeedTime() {
return needTime;
}
public void setNeedTime(int needTime) {
this.needTime = needTime;
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
public int getRoundTime() {
return roundTime;
}
public void setRoundTime(int roundTime) {
this.roundTime = roundTime;
}
public int getWaitingTime() {
return waitingTime;
}
public void setWaitingTime(int waitingTime) {
this.waitingTime = waitingTime;
}
public int getLastTime() {
return lastTime;
}
public void setLastTime(int lastTime) {
this.lastTime = lastTime;
}
public String toString() {
return this.name;
}
}
接下来是执行的类：
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
/**
* 进程Or线程的优先级调度
* @author BlankSpace
*/
public class Priority_scheduling {
/**
* PCB的集合
*/
private List<PCB> pcbList;
/**
* CPU时间
*/
private int cpuTime = 0;
/**
* 5个PCB
*/
private PCB p1, p2, p3, p4, p5;
/**
* 初始化块
*/
{
pcbList = new LinkedList<>();
p1 = new PCB("P1",2,1,"ready");
p2 = new PCB("P2",3,5,"ready");
p3 = new PCB("P3",1,3,"ready");
p4 = new PCB("P4",2,4,"ready");
p5 = new PCB("P5",4,2,"ready");
pcbList.add(p1);
pcbList.add(p2);
pcbList.add(p3);
pcbList.add(p4);
pcbList.add(p5);
}
public int getHighPriority() {
int i = -100;
int index = -100;
for(int j = 0; j < pcbList.size(); j++) {
int m = pcbList.get(j).getPriority();
if(pcbList.get(j).getState().equals("ready") && i < m) {
i = m;
index = j;
}
}
if(index == -100) {
return 0;
}
return index;
}
public Boolean isDone() {
boolean flag = false;
for(int j = 0; j < pcbList.size(); j++) {
if(pcbList.get(j).getState().equals("finish")) {
flag = true;
} else {
flag = false;
break;
}
}
return flag;
}
public void writeState() {
for(int j = 0; j < pcbList.size(); j++) {
System.out.println(pcbList.get(j).getName() + " " +
pcbList.get(j).getNeedTime() + " " + pcbList.get(j).getPriority() +
" " + pcbList.get(j).getState());
}
System.out.println();
}
public void run() {
System.out.println("INPUT NAME , NEEDTIME AND PRIORITY");
for (PCB pcb: pcbList) {
System.out.println(pcb.getName() + " " + pcb.getNeedTime() + " " +
pcb.getPriority());
}
System.out.println();
System.out.println("OUTPUT OF PRIORITY:");
while (!isDone()) {
int max = getHighPriority();
PCB maxObj = pcbList.get(max);
if (maxObj.getNeedTime() > 0) {
maxObj.setPriority(maxObj.getPriority()-1);
maxObj.setNeedTime(maxObj.getNeedTime()-1);
maxObj.setRoundTime(cpuTime+1);
maxObj.setWaitingTime(maxObj.getWaitingTime()+(cpuTime-maxObj.getLastTime()));
maxObj.setLastTime(cpuTime+1);
if(maxObj.getNeedTime() == 0) {
maxObj.setState("finish");
pcbList.remove(maxObj);
pcbList.add(maxObj);
} else {
maxObj.setState("working");
}
System.out.println("CPUTIME:" + cpuTime);
System.out.println("NAME NEEDTIME PRIORITY STATE");
writeState();
if(maxObj.getState().equals("working")) {
maxObj.setState("ready");
pcbList.remove(maxObj);
pcbList.add(maxObj);
}
}
cpuTime++;
}
System.out.println("NAME RoundTime WaitingTime");
pcbList.sort(new Comparator<PCB>() {
@Override
public int compare(PCB pcb1, PCB pcb2) {
return pcb1.getName().compareTo(pcb2.getName());
}
});
for (PCB pcb : pcbList) {
System.out.println(pcb.getName() + " " + pcb.getRoundTime() + " " + pcb.getWaitingTime());
}
}
public static void main(String[] args) {
new Priority_scheduling().run();
}
}
