处理机进程调度模拟

一、进程调度

 

无论是在批处理还是分时系统中，用户进程数一般都多于处理机数、这将导致它们互相争夺处理机。另外，系统进程也同样需要使用处理机。这就要求进程调度程序按一定的策略，动态地把处理机分配给处于就绪队列中的某一个进程，以使之执行。进程调度属于处理机调度。

 

处理机调度分为三个层次：

高级调度：(High-Level Scheduling)又称为长程调度、作业调度，它决定把外存上处于后备队列中的作业调入内存运行，为他们创建进程、分配必要的资源，放入就绪队列

低级调度：(Low-Level Scheduling)又称为短程调度、进程调度，它决定把就绪队列的某进程获得处理机，并由分派程序将处理机分配给被选中的进程

中级调度：(Intermediate-Level Scheduling)又称为在虚拟存储器中引入，在内、外存对换区进行进程对换，把外存上那些已经预备运行条件的就绪进程再重新调入内存，放入就绪队列。

 

 

 

二、常用调度算法模拟

 

 

首先创建一个进程控制块(PCB)的类:

 

 1 package controlblock;
 2 
 3 /**
 4  * 进程控制块
 5  *
 6  * @author wz
 7  *
 8  * @date 2015年11月10日
 9  */
10 public class PCB {
11     private int pid;
12     private double priority;
13     private int arriveTime;
14     private int needTime;
15     
16     public PCB(int pid,int arriveTime,int needTime){
17         this.pid = pid;
18         this.arriveTime = arriveTime;
19         this.needTime = needTime;
20     }
21 
22     public PCB(int pid, double priority, int arriveTime, int needTime) {
23         super();
24         this.pid = pid;
25         this.priority = priority;
26         this.arriveTime = arriveTime;
27         this.needTime = needTime;
28     }
29 
30     public int getPid() {
31         return pid;
32     }
33 
34     public double getPriority() {
35         return priority;
36     }
37 
38     public void setPriority(double priority) {
39         this.priority = priority;
40     }
41 
42     public int getArriveTime() {
43         return arriveTime;
44     }
45 
46     public int getNeedTime() {
47         return needTime;
48     }
49 
50     public void setNeedTime(int needTime) {
51         this.needTime = needTime;
52     }
53 
54 }

 

 

1.先到先服务(first-come first-served,FCFS)调度算法

 

       先来先服务(FCFS)调度算法是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。

 

模拟算法如下：

 1 package process.schedule;
 2 
 3 import java.util.Comparator;
 4 import java.util.Iterator;
 5 import java.util.LinkedList;
 6 
 7 import controlblock.PCB;
 8 
 9 /**
10  * 先到先服务进程调度
11  *
12  * @author wz
13  *
14  * @date 2015年11月10日
15  */
16 public class FCFS {
17 
18     protected LinkedList<PCB> processQueue;
19 
20     public FCFS() {
21         processQueue = new LinkedList<PCB>();
22     }
23 
24     public void schedule() {
25         sortByArriveTime(processQueue);
26         int currentTime = 0;
27         int arriveTime;
28         PCB process;
29         Iterator<PCB> iter = processQueue.iterator();
30         while (iter.hasNext()) {
31             process = iter.next();
32             arriveTime = process.getArriveTime();
33             System.out.print("进程：" + process.getPid() + ",");
34             System.out.print("到达时间：" + process.getArriveTime() + ",");
35             System.out.print("需要时间:" + process.getNeedTime() + ",");
36 
37             if (arriveTime > currentTime)
38                 currentTime = arriveTime;
39             System.out.print("开始时间：" + currentTime + ",");
40 
41             currentTime += process.getNeedTime();
42             System.out.println("结束时间：" + currentTime);
43             iter.remove();
44         }
45     }
46 
47     public void addProcess(int pid, int arriveTime, int needTime) {
48         processQueue.push(new PCB(pid, arriveTime, needTime));
49     }
50 
51     /**
52      * 对进程队列按到达时间排序
53      * 
54      * @param processQueue
55      */
56     private <T> void sortByArriveTime(LinkedList<PCB> processQueue) {
57         processQueue.sort((p1, p2) -> {
58             Integer p1Time = p1.getArriveTime();
59             Integer p2Time = p2.getArriveTime();
60             return p1Time.compareTo(p2Time);
61         });
62 
63     }
64 
65 }

 

具体思想是用随机数生成多个PCB对象，放入FCFS的进程队列processQueue中，调度算法首先按照进程的到达时间递增排序，然后再从进程队列中依次取出进程，计算其开始时间、结束时间。

 

2.短作业优先(short job first,SJF)调度算法

 

        短作业(进程)优先调度算法(SJF)，是指对短作业或短进程优先调度的算法。它们可以分别用于作业调度和进程调度。短作业优先(SJF)的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。而短进程优先(SPF)调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再重新调度。

 

模拟算法如下：

 1 package process.schedule;
 2 
 3 import java.util.Comparator;
 4 import java.util.LinkedList;
 5 
 6 import controlblock.PCB;
 7 import dispatcher.Dispatcher;
 8 
 9 /**
10  * 短作业优先调度
11  *
12  * @author wz
13  *
14  * @date 2015年11月10日
15  */
16 public class SJF{
17 
18     protected LinkedList<PCB> processQueue;
19     
20     public SJF() {
21         processQueue = new LinkedList<PCB>();
22     }
23 
24     public void schedule() {
25         sortByArriveTime(processQueue);
26         PCB process, tempProcess;
27         int arriveTime, needTime, minIndex, minNeedTime, currentTime = 0;
28 
29         while (!processQueue.isEmpty()) {
30 
31             process = processQueue.pollFirst();
32             arriveTime = process.getArriveTime();
33             needTime = process.getNeedTime();
34 
35             if (currentTime < arriveTime)
36                 currentTime = arriveTime;
37 
38             minIndex = -1;
39             minNeedTime = Dispatcher.getMaxNeedTime() + 2;
40 
41             // 要执行进程时，挑选已到达的需要作业时间最短的进程
42             for (int i = 0; i < processQueue.size(); i++) {
43                 tempProcess = processQueue.get(i);
44                 if (tempProcess.getArriveTime() > currentTime + needTime)
45                     break;
46                 // 到达时间相同，挑选最短作业为当前作业
47                 if (tempProcess.getArriveTime() == arriveTime && tempProcess.getNeedTime() < needTime) {
48                     processQueue.set(i, process);
49                     process = tempProcess;
50                     tempProcess = processQueue.get(i);
51                     needTime = process.getNeedTime();
52                 }
53                 if (tempProcess.getNeedTime() < minNeedTime) {
54                     minIndex = i;
55                     minNeedTime = tempProcess.getNeedTime();
56                 }
57             }
58             // 将最短作业放入队首
59             if (minIndex != -1) {
60                 tempProcess = processQueue.remove(minIndex);
61                 processQueue.addFirst(tempProcess);
62             }
63 
64             System.out.print("进程：" + process.getPid() + ",到达时间：" + process.getArriveTime() + ",需要时间:"
65                     + process.getNeedTime() + ",开始时间：" + currentTime + ",");
66             currentTime += needTime;
67             System.out.println("结束时间：" + currentTime);
68         }
69 
70     }
71 
72     public void addProcess(int pid, int arriveTime, int needTime) {
73         PCB process = new PCB(pid, arriveTime, needTime);
74         processQueue.push(process);
75     }
76 
77     /**
78      * 对进程队列按到达时间排序
79      * 
80      * @param processQueue
81      */
82     private <T> void sortByArriveTime(LinkedList<PCB> processQueue) {
83         processQueue.sort((p1, p2) -> {
84             Integer p1Time = p1.getArriveTime();
85             Integer p2Time = p2.getArriveTime();
86             return p1Time.compareTo(p2Time);
87         });
88 
89     }
90 }

 

具体思想是用随机数生成多个PCB对象，放入SJF的进程队列processQueue中，然后：

①调度算法首先按照进程的到达时间递增排序，然后在队列不为空的情况下执行②

②队首PCB出队(本次要执行的作业)

③遍历进程队列，若有到达时间与出队PCB相同，则找出所需作业时间最短的作业，两者交换。(确保当前作业为最短作业)

④找出已出队进程的执行结束时间前到达的所有作业中所需作业时间最短作业程(查找下一个要执行的作业)，放入队首

⑤计算已出队进程(本次的最短作业)运行的开始时间、结束时间。

⑥若队列不为空，执行②，否则结束

 

 

3.高响应比优先调度算法(Heigest Response Ratio Next,HRRN)

 

　　　在批处理系统中，短作业优先算法是一种比较好的算法，其主要的不足之处是长作业的运行得不到保证，容易出现饥饿现象。为每个作业引入前面所述的动态优先权，并使作业的优先级随着等待时间的增加而以速率a 提高，则长作业在等待一定的时间后，必然有机会分配到处理机。该优先权的变化规律可描述为：

 

　　　　　　　　　　　　　　

 

由于等待时间与服务时间之和就是系统对该作业的响应时间，故该优先权又相当于响应比RP。据此，又可表示为：

 

　　　　　　　　　　　 

 

模拟算法如下：

 1 package process.schedule;
 2 
 3 import java.util.Comparator;
 4 import java.util.LinkedList;
 5 
 6 import controlblock.PCB;
 7 
 8 /**
 9  * 高响应比优先调度
10  *
11  * @author wz
12  *
13  * @date 2015年11月10日
14  */
15 public class HRRN {
16     
17     protected LinkedList<PCB> processQueue;
18     
19     public HRRN() {
20         processQueue = new LinkedList<PCB>();
21     }
22 
23     public void schedule() {
24         sortByArriveTime(processQueue);
25         PCB process, tempProcess;
26         int arriveTime, needTime, maxIndex, currentTime = 0;
27         double respRatio, maxPriority = 0;
28 
29         while (!processQueue.isEmpty()) {
30 
31             process = processQueue.pollFirst();
32             arriveTime = process.getArriveTime();
33             needTime = process.getNeedTime();
34 
35             if (currentTime < arriveTime)
36                 currentTime = arriveTime;
37 
38             maxIndex = -1;
39             maxPriority = -1;
40             // 当前进程执行完后，挑选已到达的响应比最高的进程
41             for (int i = 0; i < processQueue.size(); i++) {
42                 tempProcess = processQueue.get(i);
43                 if (tempProcess.getArriveTime() > currentTime + needTime)
44                     break;
45                 respRatio = (currentTime + needTime - tempProcess.getArriveTime()) / (double) tempProcess.getNeedTime() + 1;
46                 tempProcess.setPriority(respRatio);
47                 if (respRatio > maxPriority) {
48                     maxIndex = i;
49                     maxPriority = respRatio;
50                 }
51             }
52             // 将响应比最高的进程放入队首
53             if (maxIndex != -1) {
54                 tempProcess = processQueue.remove(maxIndex);
55                 processQueue.addFirst(tempProcess);
56             }
57 
58             System.out.print("进程：" + process.getPid() + ",响应比：" + process.getPriority() + ",到达时间："
59                     + process.getArriveTime() + ",需要时间:" + process.getNeedTime() + ",开始时间：" + currentTime + ",");
60             currentTime += needTime;
61             System.out.println("结束时间：" + currentTime);
62         }
63     }
64 
65     public void addProcess(int pid, int arriveTime, int needTime) {
66         PCB process = new PCB(pid, arriveTime, needTime);
67         processQueue.push(process);
68     }
69 
70     /**
71      * 对进程队列按到达时间排序
72      * 
73      * @param processQueue
74      */
75     private <T> void sortByArriveTime(LinkedList<PCB> processQueue) {
76         processQueue.sort((p1, p2) -> {
77             Integer p1Time = p1.getArriveTime();
78             Integer p2Time = p2.getArriveTime();
79             return p1Time.compareTo(p2Time);
80         });
81     }
82 
83 }

 

具体思想是用随机数生成多个PCB对象，放入HRRN的进程队列processQueue中，然后：

①按照进程的到达时间递增排序，在队列不为空的情况下执行②

②队首PCB出队(本次要执行的作业)

③遍历进程队列中已出队作业的执行结束时间前到达的所有作业，计算响应比，找出最高响应比的作业，放入队首

④计算已出队进程(本次的响应比最高的作业)运行的开始时间、结束时间。

⑤若队列不为空，执行②，否则结束

 

 

4.时间片轮转法(round robin,RR)

 

       在早期的时间片轮转法中，系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU 分配给队首进程，并令其执行一个时间片。时间片的大小从几ms 到几百ms。当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。这样就可以保证就绪队列中的所有进程在一给定的时间内均能获得一时间片的处理机执行时间。换言之，系统能在给定的时间内响应所有用户的请求。

 

模拟算法如下：

 1 package process.schedule;
 2 
 3 import java.util.Comparator;
 4 import java.util.LinkedList;
 5 
 6 import controlblock.PCB;
 7 
 8 /**
 9  * 时间片轮转调度
10  *
11  * @author wz
12  *
13  * @date 2015年11月10日
14  */
15 public class RR {
16     
17     protected LinkedList<PCB> processQueue;
18 
19     private static final int TIME_SLICE = 5;
20 
21     public RR() {
22         processQueue = new LinkedList<PCB>();
23     }
24 
25     public void schedule() {
26         sortByArriveTime(processQueue);
27 
28         PCB process;
29         int currentTime = 0;
30         int arriveTime;
31         int needTime;
32 
33         while (!processQueue.isEmpty()) {
34             process = processQueue.pollFirst();
35             needTime = process.getNeedTime();
36             arriveTime = process.getArriveTime();
37             System.out.print("进程：" + process.getPid() + ",");
38             System.out.print("到达时间：" + process.getArriveTime() + ",");
39             System.out.print("还需要时间:" + process.getNeedTime() + ",");
40 
41             if (currentTime < arriveTime)
42                 currentTime = arriveTime;
43             System.out.print("开始时间：" + currentTime + ",");
44 
45             if (TIME_SLICE < needTime) {
46                 currentTime += TIME_SLICE;
47                 System.out.println("进程中断时间：" + currentTime);
48                 process.setNeedTime(needTime - TIME_SLICE);
49                 for (int i = 0; i < processQueue.size(); i++) {
50                     if (processQueue.get(i).getArriveTime() > currentTime) {
51                         processQueue.add(i, process);
52                         break;
53                     } else if (i == processQueue.size() - 1) {
54                         processQueue.add(process);
55                         break;
56                     }
57                 }
58             } else {
59                 currentTime += needTime;
60                 System.out.println("结束时间：" + currentTime);
61             }
62         }
63 
64     }
65 
66     public void addProcess(int pid, int arriveTime, int needTime) {
67         processQueue.push(new PCB(pid, arriveTime, needTime));
68     }
69 
70     /**
71      * 对进程队列按到达时间排序
72      * 
73      * @param processQueue
74      */
75     private <T> void sortByArriveTime(LinkedList<PCB> processQueue) {
76         processQueue.sort((p1, p2) -> {
77             Integer p1Time = p1.getArriveTime();
78             Integer p2Time = p2.getArriveTime();
79             return p1Time.compareTo(p2Time);
80         });
81 
82     }
83 
84 }

 

具体思想是用随机数生成多个PCB对象，放入RR的进程队列processQueue中，然后：

①按照进程的到达时间递增排序，在队列不为空的情况下执行②

②队首PCB出队(本次要执行的作业)

③为已出队进程分配时间片，计算运行的开始时间、中断时间或结束时间。

④若出队进程没有执行完，则将该PCB插入到进程队列中当前进程中断时间前所到达的作业的最后

⑤若队列不为空，执行②，否则结束

 

 

5.优先级调度算法(priority-scheduling algorithm,PSA)

 

       此算法常被用于批处理系统中，作为作业调度算法，也作为多种操作系统中的进程调度算法，还可用于实时系统中。当把该算法用于作业调度时，系统将从后备队列中选择若干个优先权最高的作业装入内存。当用于进程调度时，该算法是把处理机分配给就绪队列中优先权最高的进程，这时，又可进一步把该算法分为抢占式(Preemptive Mode)和非抢占式(Nonpreemptive Mode)。

 

      这里的调度算法采用抢占式(Preemptive Mode)优先级调度。 

      在这种方式下，系统同样是把处理机分配给优先权最高的进程，使之执行。但在其执行期间，只要又出现了另一个其优先权更高的进程，进程调度程序就立即停止当前进程(原优先权最高的进程)的执行，重新将处理机分配给新到的优先权最高的进程。因此，在采用这种调度算法时，是每当系统中出现一个新的就绪进程i 时，就将其优先权Pi与正在执行的进程j 的优先权Pj进行比较。如果Pi≤Pj，原进程Pj便继续执行；但如果是Pi>Pj，则立即停止Pj的执行，做进程切换，使i 进程投入执行。显然，这种抢占式的优先权调度算法能更好地满足紧迫作业的要求，故而常用于要求比较严格的实时系统中，以及对性能要求较高的批处理和分时系统中。

 

模拟算法如下：

  1 package process.schedule;
  2 
  3 import controlblock.PCB;
  4 
  5 import java.util.LinkedList;
  6 import java.util.List;
  7 
  8 /**
  9  * 优先权调度(抢占式)
 10  *
 11  * @author wz
 12  *
 13  * @date 2015年11月10日
 14  */
 15 public class PSA {
 16 
 17     protected LinkedList<PCB> processQueue;
 18 
 19     public PSA() {
 20         processQueue = new LinkedList<>();
 21     }
 22 
 23     public void schedule() {
 24         sortByArriveTime(processQueue);
 25         PCB process, tempProcess;
 26         int arriveTime, needTime, runTime, currentTime = 0;
 27         while (!processQueue.isEmpty()) {
 28             process = processQueue.pollFirst();
 29             arriveTime = process.getArriveTime();
 30 
 31             if (currentTime < arriveTime)
 32                 currentTime = arriveTime;
 33 
 34             for (int i = 0; i < processQueue.size(); i++) {
 35                 needTime = process.getNeedTime();
 36                 tempProcess = processQueue.get(i);
 37                 if (tempProcess.getArriveTime() > currentTime + needTime)
 38                     break;
 39                 // 当前进程执行至被高优先级进程抢占
 40                 if (tempProcess.getPriority() < process.getPriority()) {
 41                     if (tempProcess.getArriveTime() != currentTime) {
 42                         processQueue.remove(i);
 43                         System.out.print("进程：" + process.getPid() + ",优先级：" + (int) process.getPriority() + ",到达时间："
 44                                 + process.getArriveTime() + ",需要时间:" + process.getNeedTime() + ",开始时间：" + currentTime
 45                                 + ",");
 46                         runTime = tempProcess.getArriveTime() - currentTime;
 47                         process.setNeedTime(needTime - runTime);
 48                         currentTime += runTime;
 49                         System.out.println("进程中断时间：" + currentTime);
 50                         processQueue.addFirst(process);
 51                         process = tempProcess;
 52                     } else {
 53                         processQueue.set(i, process);
 54                         process = tempProcess;
 55                         tempProcess = processQueue.get(i);
 56                         // needTime = process.getNeedTime();
 57                     }
 58 
 59                 } else {
 60                     subSortByPriority(processQueue, 0, i + 1);
 61                 }
 62             }
 63 
 64             System.out.print("进程：" + process.getPid() + ",优先级：" + (int) process.getPriority() + ",到达时间："
 65                     + process.getArriveTime() + ",需要时间:" + process.getNeedTime() + ",开始时间：" + currentTime + ",");
 66             currentTime += process.getNeedTime();
 67             System.out.println("结束时间：" + currentTime);
 68         }
 69     }
 70 
 71     public void addProcess(int pid, int priority, int arriveTime, int needTime) {
 72         processQueue.push(new PCB(pid, priority, arriveTime, needTime));
 73     }
 74 
 75     /**
 76      * 对进程队列按到达时间排序
 77      * 
 78      * @param processQueue
 79      */
 80     private <T> void sortByArriveTime(LinkedList<PCB> processQueue) {
 81         processQueue.sort((p1, p2) -> {
 82             Integer p1Time = p1.getArriveTime();
 83             Integer p2Time = p2.getArriveTime();
 84             return p1Time.compareTo(p2Time);
 85         });
 86     }
 87 
 88     /**
 89      * 对指定子队列按优先级排序
 90      * 
 91      * @param processQueue
 92      * @param fromIndex
 93      * @param toIndex
 94      */
 95     private void subSortByPriority(LinkedList<PCB> processQueue, int fromIndex, int toIndex) {
 96         List<PCB> subQueue = processQueue.subList(fromIndex, toIndex);
 97         subQueue.sort((p1, p2) -> {
 98             Double p1Priority = p1.getPriority();
 99             Double p2Priority = p2.getPriority();
100             return p1Priority.compareTo(p2Priority);
101         });
102     }
103 
104 }

 

具体思想是用随机数生成多个PCB对象，放入PSA的进程队列processQueue中，然后：

①按照进程的到达时间递增排序，在队列不为空的情况下执行②

②队首PCB出队(第一个到达的作业或优先级最高的作业)

③遍历进程队列，查找当前PCB结束时间前到达的所有PCB，若优先级高于当前执行的作业，执行④，否则执行⑤

④此时当前作业执行至被高优先级作业抢占。计算当前作业本次运行的开始时间、中断时间，并放入队首(优先级高的放在队首，当前执行作业是目前已查找到的优先级次高的作业)，将③查找到的高优先级的作业出队，成为当前执行的作业(高优先级作业抢占处理机)。然后继续执行③向后遍历

⑤对队列中已经遍历的PCB按优先级递减就地排序(保证已到达进程按优先级递减排列)。若未遍历完，继续执行③向后遍历

⑥计算当前进程本次执行的开始时间、结束时间。

⑦若队列不为空，执行②，否则结束

 

暂时就写了这几种调度算法的模拟，下面是生成随机PCB测试的代码：

  1 package dispatcher;
  2 
  3 import java.util.Random;
  4 
  5 import process.schedule.FCFS;
  6 import process.schedule.HRRN;
  7 import process.schedule.PSA;
  8 import process.schedule.RR;
  9 import process.schedule.SJF;
 10 
 11 /**
 12  * 分派程序
 13  *
 14  * @author wz
 15  *
 16  * @date 2015年11月10日
 17  */
 18 public class Dispatcher {
 19 
 20     private static final int MAX_ARRIVE_TIME = 5;
 21     private static final int MAX_NEED_TIME = 10;
 22     private static final int MAX_PROCESS_NUM = 5;
 23     private static final int MAX_PRIORITY = 10;
 24     private final static int MAX_PID = 10000;
 25 
 26     public static void main(String[] args) {
 27         FCFSSchedule();
 28         SJFSchedule();
 29         RRShedule();
 30         PSAShedule();
 31         HRRNShedule();
 32     }
 33 
 34     /**
 35      * 高响应比优先调度
 36      */
 37     private static void HRRNShedule() {
 38         HRRN hrrn = new HRRN();
 39         HRRN ps = hrrn;
 40         Random random = new Random();
 41 
 42         for (int i = 0; i < MAX_PROCESS_NUM; i++) {
 43             ps.addProcess(random.nextInt(MAX_PID), random.nextInt(MAX_ARRIVE_TIME), random.nextInt(MAX_NEED_TIME) + 1);
 44         }
 45 
 46         ps.schedule();
 47     }
 48 
 49     /**
 50      * 优先权调度(抢占式)
 51      */
 52     private static void PSAShedule() {
 53         PSA ps = new PSA();
 54         Random random = new Random();
 55 
 56         for (int i = 0; i < MAX_PROCESS_NUM; i++) {
 57             ps.addProcess(random.nextInt(MAX_PID), random.nextInt(MAX_PRIORITY), random.nextInt(MAX_ARRIVE_TIME),
 58                     random.nextInt(MAX_NEED_TIME) + 1);
 59         }
 60 
 61         ps.schedule();
 62     }
 63 
 64     /**
 65      * 时间片轮转调度
 66      */
 67     private static void RRShedule() {
 68         RR ps = new RR();
 69         Random random = new Random();
 70 
 71         for (int i = 0; i < MAX_PROCESS_NUM; i++) {
 72             ps.addProcess(random.nextInt(MAX_PID), random.nextInt(MAX_ARRIVE_TIME), random.nextInt(MAX_NEED_TIME) + 1);
 73         }
 74 
 75         ps.schedule();
 76     }
 77 
 78     /**
 79      * 先到先服务
 80      */
 81     private static void FCFSSchedule() {
 82         FCFS ps = new FCFS();
 83         Random random = new Random();
 84 
 85         for (int i = 0; i < MAX_PROCESS_NUM; i++) {
 86             ps.addProcess(random.nextInt(MAX_PID), random.nextInt(MAX_ARRIVE_TIME), random.nextInt(MAX_NEED_TIME) + 1);
 87         }
 88 
 89         ps.schedule();
 90     }
 91 
 92     /**
 93      * 短作业优先调度
 94      */
 95     private static void SJFSchedule() {
 96         SJF ps = new SJF();
 97         Random random = new Random();
 98 
 99         for (int i = 0; i < MAX_PROCESS_NUM; i++) {
100             ps.addProcess(random.nextInt(MAX_PID), random.nextInt(MAX_ARRIVE_TIME), random.nextInt(MAX_NEED_TIME) + 1);
101         }
102 
103         ps.schedule();
104     }
105 
106     public static int getMaxNeedTime() {
107         return MAX_NEED_TIME;
108     }
109 }