關於優先順序隊列的實現

   

        這幾天一直在搞關於優先順序隊列的實現,因為要考慮到線程的安全,所以PriorityQueue就不適用了。經朋友的指點，終於想到一個非常簡單的實現方法，那就是把優先順序比較好的插入一個隊列，優先順序低的插入另一個隊列，取數的時候先在優先順序高的隊列上取數。這有個缺點就是如果優先順序別越多的話，隊列就越多。        因為要安全執行緒，隊列採用ConcurrentLinkedQueue這個安全執行緒的，而api文檔上說ConcurrentLinkedQueue採用了有效“無等待 (wait-free)”演算法，所以它的輸送量是很不錯的！    簡單代碼如下：

1. package test;
3. import java.util.concurrent.ConcurrentLinkedQueue;
5. public class PriorityQueueTest {
7.     public static void main(String[] args) {
8.         ConcurrentLinkedQueue<String> highPriority = new ConcurrentLinkedQueue<String>(); //高優先順序
9.         ConcurrentLinkedQueue<String> lowPriority = new ConcurrentLinkedQueue<String>();  //低優先順序
10.         
11.         highPriority.add("aaa");
12.         highPriority.add("bbb");
13.         highPriority.add("111");
14.         
15.         lowPriority.add("ccc");
16.         lowPriority.add("ddd");
17.         lowPriority.add("222");
18.         
19.         int i = 0 ,j = 0, k=0;
20.         while(true){
21.             while(true){
22.                 if(!highPriority.isEmpty()){
23.                     System.out.print(highPriority.remove());
24.                     i++;
25.                     k++;
26.                     System.out.println(", i = "+i+", k="+k);
27.                     break;
28.                 }
29.                 if(!lowPriority.isEmpty()){
30.                     System.out.print(lowPriority.remove());
31.                     j++;
32.                     k++;
33.                     System.out.println(", j = "+j+", k="+k);
34.                     break;
35.                 }
36.                 break;
37.             }
38.             try {
39.                 Thread.sleep(100);
40.             } catch (InterruptedException e) {
41.                 e.printStackTrace();
42.             }
43.         }
44.     }
45. }

       結果：               還有一種是，通過繼承PriorityQueue並實現Comparable介面，然後自已重寫過compareTo方法就能實現很強大的優先順序隊列了，不過缺點是線程不安全的！      代碼如下：

1. package test;
3. import java.util.PriorityQueue;
5. public class PriorityTest extends PriorityQueue<PriorityTest.Test>{
6.     static class Test implements Comparable<Test>{
7.         String packet;
8.         int priotity;
9.         
10.         public Test(String packet, int priotity) {
11.             this.packet = packet;
12.             this.priotity = priotity;
13.         }
14.         
15.         public int compareTo(Test arg) { 
16.             if(priotity < arg.priotity)
17.                 return 1;
18.             else if(priotity > arg.priotity)
19.                 return -1;
20.             else
21.                 return 0;
22.         } 
23.         
24.         public String toString(){
25.             return packet; 
26.         }
27.     }
28.     
29.     public void add(String str, int priority){
30.         super.add(new Test(str,priority));
31.     }
32.     
33.     public static void main(String args[]){
34.         PriorityTest pTest = new PriorityTest();
35.         pTest.add("aaa",3);  //優先順序最高
36.         pTest.add("bbb",2);
37.         pTest.add("ccc",1);
38.         
39.         while(!pTest.isEmpty()){
40.             System.out.println(pTest.remove());
41.         }
42.     }
43. }