Queue： 基本上，一個佇列就是一個先入先出（FIFO）的資料結構

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

Queue的實現

1、沒有實現的阻塞介面的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

下表顯示了jdk1.5中的阻塞佇列的操作：

　　add        增加一個元索                     如果佇列已滿，則丟擲一個IIIegaISlabEepeplian異常
　　remove   移除並返回佇列頭部的元素    如果佇列為空，則丟擲一個NoSuchElementException異常
　　element  返回佇列頭部的元素             如果佇列為空，則丟擲一個NoSuchElementException異常
　　offer    新增一個元素並返回true       如果佇列已滿，則返回false
　　poll

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();
 }
}

 出處：https://www.cnblogs.com/lemon-flm/p/7877898.html