关于优先级队列的实现 (r)

这几天一直在搞关于优先级队列的实现,因为要考虑到线程的安全,所以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. }