java隊列——queue詳細分析

 

Queue： 基本上，一個隊列就是一個先入先出（FIFO）的數據結構

Queue接口與List、Set同一級別，都是繼承了Collection接口。LinkedList實現了Deque接 口。

 

Queue的實現

一、沒有實現的阻塞接口的LinkedList： 實現了java.util.Queue接口和java.util.AbstractQueue接口
　　內置的不阻塞隊列： PriorityQueue 和 ConcurrentLinkedQueue
　　PriorityQueue 和 ConcurrentLinkedQueue 類在 Collection Framework 中加入兩個具體集合實現。 
　　PriorityQueue 類實質上維護了一個有序列表。加入到 Queue 中的元素根據它們的自然排序（經過其 java.util.Comparable 實現）或者根據傳遞給構造函數的 java.util.Comparator 實現來定位。
　　ConcurrentLinkedQueue 是基於連接節點的、線程安全的隊列。併發訪問不須要同步。由於它在隊列的尾部添加元素並從頭部刪除它們，因此只要不須要知道隊列的大 小，　　　　    　　ConcurrentLinkedQueue 對公共集合的共享訪問就能夠工做得很好。收集關於隊列大小的信息會很慢，須要遍歷隊列。

2)實現阻塞接口的：
　　java.util.concurrent 中加入了 BlockingQueue 接口和五個阻塞隊列類。它實質上就是一種帶有一點扭曲的 FIFO 數據結構。不是當即從隊列中添加或者刪除元素，線程執行操做阻塞，直到有空間或者元素可用。
五個隊列所提供的各有不一樣：
　　* ArrayBlockingQueue ：一個由數組支持的有界隊列。
　　* LinkedBlockingQueue ：一個由連接節點支持的可選有界隊列。
　　* PriorityBlockingQueue ：一個由優先級堆支持的無界優先級隊列。
　　* DelayQueue ：一個由優先級堆支持的、基於時間的調度隊列。
　　* SynchronousQueue ：一個利用 BlockingQueue 接口的簡單彙集（rendezvous）機制。

 

 

 

下表顯示了jdk1.5中的阻塞隊列的操做：

 

　　add        增長一個元索                     若是隊列已滿，則拋出一個IIIegaISlabEepeplian異常
　　remove   移除並返回隊列頭部的元素    若是隊列爲空，則拋出一個NoSuchElementException異常
　　element  返回隊列頭部的元素             若是隊列爲空，則拋出一個NoSuchElementException異常
　　offer       添加一個元素並返回true       若是隊列已滿，則返回false
　　poll         移除並返問隊列頭部的元素    若是隊列爲空，則返回null
　　peek       返回隊列頭部的元素             若是隊列爲空，則返回null
　　put         添加一個元素                      若是隊列滿，則阻塞
　　take        移除並返回隊列頭部的元素     若是隊列爲空，則阻塞

 

remove、element、offer 、poll、peek 實際上是屬於Queue接口。 

 

阻塞隊列的操做能夠根據它們的響應方式分爲如下三類：aad、removee和element操做在你試圖爲一個已滿的隊列增長元素或從空隊列取得元素時 拋出異常。固然，在多線程程序中，隊列在任什麼時候間均可能變成滿的或空的，因此你可能想使用offer、poll、peek方法。這些方法在沒法完成任務時 只是給出一個出錯示而不會拋出異常。

 

注意：poll和peek方法出錯進返回null。所以，向隊列中插入null值是不合法的

 

最後，咱們有阻塞操做put和take。put方法在隊列滿時阻塞，take方法在隊列空時阻塞。

 

 

LinkedBlockingQueue的容量是沒有上限的（說的不許確，在不指定時容量爲Integer.MAX_VALUE，不要然的話在put時怎麼會受阻呢），可是也能夠選擇指定其最大容量，它是基於鏈表的隊列，此隊列按 FIFO（先進先出）排序元素。

ArrayBlockingQueue在構造時須要指定容量， 並能夠選擇是否須要公平性，若是公平參數被設置true，等待時間最長的線程會優先獲得處理（其實就是經過將ReentrantLock設置爲true來 達到這種公平性的：即等待時間最長的線程會先操做）。一般，公平性會使你在性能上付出代價，只有在的確很是須要的時候再使用它。它是基於數組的阻塞循環隊 列，此隊列按 FIFO（先進先出）原則對元素進行排序。

PriorityBlockingQueue是一個帶優先級的 隊列，而不是先進先出隊列。元素按優先級順序被移除，該隊列也沒有上限（看了一下源碼，PriorityBlockingQueue是對 PriorityQueue的再次包裝，是基於堆數據結構的，而PriorityQueue是沒有容量限制的，與ArrayList同樣，因此在優先阻塞 隊列上put時是不會受阻的。雖然此隊列邏輯上是無界的，可是因爲資源被耗盡，因此試圖執行添加操做可能會致使 OutOfMemoryError），可是若是隊列爲空，那麼取元素的操做take就會阻塞，因此它的檢索操做take是受阻的。另外，往入該隊列中的元 素要具備比較能力。

DelayQueue（基於PriorityQueue來實現的）是一個存放Delayed 元素的無界阻塞隊列，只有在延遲期滿時才能從中提取元素。該隊列的頭部是延遲期滿後保存時間最長的 Delayed 元素。若是延遲都尚未期滿，則隊列沒有頭部，而且poll將返回null。當一個元素的 getDelay(TimeUnit.NANOSECONDS) 方法返回一個小於或等於零的值時，則出現期滿，poll就以移除這個元素了。此隊列不容許使用 null 元素。

 

 一個例子：

package com.yao;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class BlockingQueueTest {
 /**
 定義裝蘋果的籃子
  */
 public static class Basket{
  // 籃子，可以容納3個蘋果
  BlockingQueue<String> basket = new ArrayBlockingQueue<String>(3);

  // 生產蘋果，放入籃子
  public void produce() throws InterruptedException{
   // put方法放入一個蘋果，若basket滿了，等到basket有位置
   basket.put("An apple");
  }
  // 消費蘋果，從籃子中取走
  public String consume() throws InterruptedException{
   // get方法取出一個蘋果，若basket爲空，等到basket有蘋果爲止
   String apple = basket.take();
   return apple;
  }

  public int getAppleNumber(){
   return basket.size();
  }

 }
 //　測試方法
 public static void testBasket() {
  // 創建一個裝蘋果的籃子
  final Basket basket = new Basket();
  // 定義蘋果生產者
  class Producer implements Runnable {
   public void run() {
    try {
     while (true) {
      // 生產蘋果
      System.out.println("生產者準備生產蘋果：" 
        + System.currentTimeMillis());
      basket.produce();
      System.out.println("生產者生產蘋果完畢：" 
        + System.currentTimeMillis());
      System.out.println("生產完後有蘋果："+basket.getAppleNumber()+"個");
      // 休眠300ms
      Thread.sleep(300);
     }
    } catch (InterruptedException ex) {
    }
   }
  }
  // 定義蘋果消費者
  class Consumer implements Runnable {
   public void run() {
    try {
     while (true) {
      // 消費蘋果
      System.out.println("消費者準備消費蘋果：" 
        + System.currentTimeMillis());
      basket.consume();
      System.out.println("消費者消費蘋果完畢：" 
        + System.currentTimeMillis());
      System.out.println("消費完後有蘋果："+basket.getAppleNumber()+"個");
      // 休眠1000ms
      Thread.sleep(1000);
     }
    } catch (InterruptedException ex) {
    }
   }
  }

  ExecutorService service = Executors.newCachedThreadPool();
  Producer producer = new Producer();
  Consumer consumer = new Consumer();
  service.submit(producer);
  service.submit(consumer);
  // 程序運行10s後，全部任務中止
  try {
   Thread.sleep(10000);
  } catch (InterruptedException e) {
  }
  service.shutdownNow();
 }
 public static void main(String[] args) {
  BlockingQueueTest.testBasket();
 }
}