java实现短作业优先

1. package com.sirding.testalgo;  
2.   
3. import java.io.Serializable;  
4. import java.util.ArrayList;  
5. import java.util.Collections;  
6. import java.util.Comparator;  
7. import java.util.List;  
8.   
9. import org.junit.Before;  
10. import org.junit.Test;  
11.   
12. /** 
13.  * @Described   : Spf = Shortest Process First.最短优先算法 
14.  * @project     : com.sirding.testalgo.Spn 
15.  * @author      :  
16.  * @date        :  
17.  */  
18. public class Spf {  
19.   
20.     private List<SpfJob> jobList = new ArrayList<SpfJob>();  
21.     private long[] arr = {1, 4, 10, 7};  
22.       
23.     /** 
24.      * @Described           : 单通道多任务不同时到达 
25.      * @author              :  
26.      * @date                : 
27.      */  
28. //  @Before  
29.     public void diffTime(){  
30.         long start = System.currentTimeMillis();  
31.         for(long tmp : arr){  
32.             jobList.add(new SpfJob(start + (int)(Math.random()*100), tmp));  
33.         }  
34.         sortList();  
35.     }  
36.       
37.     /** 
38.      * @Described           : 单通道多任务同时到达 
39.      * @author              :  
40.      * @date                :  
41.      */  
42.     @Before  
43.     public void sameTime(){  
44.         long start = System.currentTimeMillis();  
45.         for(long tmp : arr){  
46.             jobList.add(new SpfJob(start, tmp));  
47.         }  
48.         sortList();  
49.     }  
50.       
51.     private void sortList() {  
52.         Collections.sort(jobList, new Comparator<SpfJob>() {  
53.             @Override  
54.             public int compare(SpfJob o1, SpfJob o2) {  
55.                 return (int)(o1.execTime - o2.execTime);  
56.             }  
57.         });  
58.     }  
59.       
60.     /** 
61.      * @Described           : 单通道最短优先算法-计算平均周转时间 
62.      *                          测试用例: 
63.      *                              多个任务同时到达，sameTime()初始化数据 
64.      * @author              : zc.ding 
65.      * @date                :  
66.      */  
67.     @Test  
68.     public void test(){  
69. //      方式一：逐步计算每个任务的周转时间  
70.         long total = 0;  
71.         long costTime = 0;  
72.         for(SpfJob job : jobList){  
73.             costTime = (costTime + job.getExecTime());  
74.             total += costTime;  
75.             System.out.println("job_" + job.execTime + "周转时间:" + costTime);  
76.         }  
77.           
78. //      方法二:通过阶乘的方式计算  
79. //      for(int i = 0; i < jobList.size(); i++){  
80. //          total += (jobList.size() - i) * jobList.get(i).getExecTime();  
81. //      }  
82.         System.out.println("总周转时间：" + total);  
83.         System.out.println("平均周转时间：" + ((double)total/(double)jobList.size()));  
84.     }     
85.       
86.     /** 
87.      * @Described   : 任务信息 
88.      * @project     : com.sirding.testalgo.SpfJob 
89.      * @author      : zc.ding 
90.      * @date        :  
91.      */  
92.     static class SpfJob implements Serializable{  
93.         /** 
94.          *  
95.          */  
96.         private static final long serialVersionUID = 1L;  
97.         //到达时间  
98.         private long arrivalTime;  
99.         //执行时间  
100.         private long execTime;  
101.         //任务开始时间  
102.         private long startTime;  
103.         //任务结束时间  
104.         private long endTime;  
105.         //周转时间  
106.         private long totalTime;  
107.           
108.         public SpfJob(){}  
109.           
110.         public SpfJob(long startTime, long execTime){  
111.             this.startTime = startTime;  
112.             this.execTime = execTime;  
113.         }  
114.           
115.         public long getArrivalTime() {  
116.             return arrivalTime;  
117.         }  
118.         public void setArrivalTime(long arrivalTime) {  
119.             this.arrivalTime = arrivalTime;  
120.         }  
121.         public long getExecTime() {  
122.             return execTime;  
123.         }  
124.         public void setExecTime(long execTime) {  
125.             this.execTime = execTime;  
126.         }  
127.         public long getStartTime() {  
128.             return startTime;  
129.         }  
130.         public void setStartTime(long startTime) {  
131.             this.startTime = startTime;  
132.         }  
133.         public long getEndTime() {  
134.             return endTime;  
135.         }  
136.         public void setEndTime(long endTime) {  
137.             this.endTime = endTime;  
138.         }  
139.         public long getTotalTime() {  
140.             return totalTime;  
141.         }  
142.         public void setTotalTime(long totalTime) {  
143.             this.totalTime = totalTime;  
144.         }  
145.     }  
146. }