java中关于优先级队列的实现

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