CPU进程调度简单模拟(PriorityFirst)--Java

这是我的作业，要求的输出结果是：各进程的等待时间、周转时间及平均等待、周转时间
进程的基本信息我直接写在了程序里（懒得运行时一一输入）。写了两个Class，一个储存进程的基本信息(Work)，一个模拟进程(Test)

Work Class：

/* * Student name: Xin * Program name: Work * Program purpose: Test the scheduling algorithm sumulation (PriorityFirst) */import java.util.*;public class Work implements Comparable {// 用 ComparaTo 在 jobQueue中对进程第一次排序@Overridepublic int compareTo(Object o){    //如果进程的到达时间相同，则以优先级排序。否则按到达时间排序    Work p = (Work)o;    if(this.arrivalTime == p.arrivalTime)    return this.priority < p.priority ? -1:1;    else    return this.arrivalTime < p.arrivalTime ? -1:1;}// 变量：到达时间，运行时间，优先级，进程名private int arrivalTime;private int burstTime;private int priority;private String name;// 变量：平均等待时间，平均周转时间private int turnAroundTime;private int waitingTime;// 获取变量值public int getArrivalTime() {return arrivalTime;}public int getPriority() {return priority;}public int getBurstTime() {return burstTime;}public String getName() {return name;}public int getWaitingTime() {return waitingTime;}public int getTurnAroundTime() {return turnAroundTime;}// 设置变量值public void setArrivalTime(int arrivalTime) {this.arrivalTime = arrivalTime;}public void setBurstTime(int burstTime) {this.burstTime = burstTime;}public void setPriority(int priority) {this.priority = priority;}public void setName(String name) {this.name = name;}public void setWaitingTime(int waitingTime) {this.waitingTime = waitingTime;}public void setTurnAroundTime(int turnAroundTime) {this.turnAroundTime = turnAroundTime;}// 第一组数据（进程同时到达）public static PriorityQueue<Work> generateProcess1(){String[] name1 = {"A","B","C","D","E"};int[] at1 = {0,0,0,0,0};int[] bt1 = {7,3,9,5,1};int[] pri1 = {3,5,2,1,4};PriorityQueue<Work> runQueue1= new PriorityQueue<>();for(int i = 0; i<5;i++){    Work process = new Work();    process.setName(name1[i]);    process.setArrivalTime(at1[i]);    process.setBurstTime(bt1[i]);    process.setPriority(pri1[i]);    runQueue1.add(process);}return runQueue1;}// 第二组数据（到达时间不同）public static PriorityQueue<Work> generateProcess2(){String[] name2 = {"A","B","C","D","E"};int[] at2 = {0,2,4,6,8};int[] bt2 = {7,3,9,5,1};int[] pri2 = {3,5,2,1,4};PriorityQueue<Work> runQueue2= new PriorityQueue<>();for(int i = 0; i<5;i++){    Work process = new Work();    process.setName(name2[i]);    process.setArrivalTime(at2[i]);    process.setBurstTime(bt2[i]);    process.setPriority(pri2[i]);    runQueue2.add(process);}return runQueue2;}}

Test Class：

/* * Student name: Xin * Program name: Test (Program 3) * Program purpose: Test the scheduling algorithm sumulation (PriorityFirst) */import java.util.*;/* * 思路：要实现优先级算法模拟，考虑优先级外也要考虑进程的到达时间（如果进程先到达，即使它的优先级低，也要先运行）。因此我在原始的JobQUEUE和后来的readyQUEUE分别对进程进行排序。在jobQUEUE里，如果进程的到达时间不同，则按到达时间先后排序；在readyQUEUE里，则按优先级排序。这样可以确保每一个进程进入readyQUEUE时，都是先到达的进程 */public class Test  {public static int numberOfProcess;// 用 Comparator 对readyQueue里的进程进行排序，根据优先级public static Comparator<Work> theComparator = new Comparator<Work>(){    public int compare(Work work1, Work work2){        return work1.getPriority() < work2.getPriority()? -1:1;}}; // Main methodpublic static void main(String[] args) {    Scanner userInput = new Scanner(System.in);    // 用户输入进程数    System.out.println("Enter the # of processes.");    numberOfProcess = userInput.nextInt();    // 创建两个 PriorityQueue q1,q2    PriorityQueue<Work> q1 = new PriorityQueue<>();    PriorityQueue<Work> q2 = new PriorityQueue<>();    //  generateProcess method 对进程进行排序    q1 = Work.generateProcess1();    q2 = Work.generateProcess2();    System.out.println("\nThe running order and details of data set 1: ");    priorityFirst(q1);    System.out.println("\nThe running order and details of data set 2: ");    priorityFirst(q2);}// The priorityFirst method public static Queue<Work> priorityFirst(PriorityQueue<Work> queue) {    // 设置变量    double averageWaitTime = 0.00;    double averageTurnAroundTime = 0.00;    int startTime = 0;    int finishTime = 0;    int queueSize = queue.size();    Work process;    // 创建readyQueue(大小为进程的数量，用Comparetor排序进程)       PriorityQueue<Work> readyQueue = new PriorityQueue<Work>(numberOfProcess, theComparator);        // (这个数字是我随便设的-。- 我也不太确定要loop多少次)        for (int i = 0; i<10;i++){        // 当queue和readyQueue其中有不为空时（即还有进程没有运行）        while(!queue.isEmpty() || !readyQueue.isEmpty()){            // 看readyQueue是否为空，若为空，则意味着所有READY state 的进程都完成运行了。此时从queue中取下一个进程            process=readyQueue.isEmpty()? queue.poll():readyQueue.poll();            // 计算开始时间，结束时间            startTime = finishTime;            finishTime = startTime + process.getBurstTime();            // 如果queue里第一个进程的到达时间小于刚刚进入readyQueue的进程的结束时间（即意味着当刚刚进入的那个进程，完成运行，下一个进程已会到达），则queue里的进程可以继续被加入到readyQueue            while(queue.peek()!=null && queue.peek().getArrivalTime()<=finishTime)            readyQueue.add(queue.poll());            // 计算等待时间（开始时间-到达时间）            process.setWaitingTime(startTime-process.getArrivalTime());            // 输入等待时间            System.out.println(process.getName()+" Process's waiting time:"+process.getWaitingTime());            // 计算周转时间（结束时间-到达时间）            process.setTurnAroundTime(finishTime-process.getArrivalTime());            // 输出到达时间            System.out.println(process.getName()+" Process's turn around time:"+process.getTurnAroundTime());            // 计算平均值            averageWaitTime = averageWaitTime + process.getWaitingTime();            averageTurnAroundTime = averageTurnAroundTime + process.getTurnAroundTime();        }}// 计算平均值averageTurnAroundTime /= queueSize;averageWaitTime /= queueSize;// 输出平均值System.out.println("\nAverage Wait time: "+ averageWaitTime);System.out.println("Average Turn Around time: "+ averageTurnAroundTime);return readyQueue;  }}

最终输出结果：