併發容器與框架——併發容器（二）

1.何為阻塞佇列

    阻塞佇列（BlockingQueue）是一個支援兩個附加操作的佇列。這兩個附加的操作支援阻塞的插入和移除方法。

1. 支援阻塞的插入方法：意思是當佇列滿（無界佇列除外）時，佇列會阻塞插入元素的執行緒，直到佇列不滿。
2. 支援阻塞的移除方法：意思是在佇列為空時，獲取元素的執行緒會等待佇列變為非空。

    阻塞佇列常用於生產者和消費者的場景，生產者是向佇列裡新增元素的執行緒，消費者是從佇列裡取元素的執行緒。阻塞佇列就是生產者用來存放元素、消費者用來獲取元素的容器。阻塞佇列對插入和移除兩個附加操作提供了4種處理方式。

1. 丟擲異常：當佇列滿時，如果再往佇列裡插入元素，會丟擲IllegalStateException（”Queuefull”）異常。當佇列空時，從佇列裡獲取元素會丟擲NoSuchElementException異常。
2. ·返回特殊值：當往佇列插入元素時，會返回元素是否插入成功，成功返回true。如果是移除方法，則是從佇列裡取出一個元素，如果沒有則返回null。
3. ·一直阻塞：當阻塞佇列滿時，如果生產者執行緒往佇列裡put元素，佇列會一直阻塞生產者執行緒，直到佇列可用或者響應中斷退出。當佇列空時，如果消費者執行緒從佇列裡take元素，佇列會阻塞住消費者執行緒，直到佇列不為空。
4. ·超時退出：當阻塞佇列滿時，如果生產者執行緒往佇列裡插入元素，佇列會阻塞生產者執行緒一段時間，如果超過了指定的時間，生產者執行緒就會退出。

    注意：如果是無界阻塞佇列，佇列不可能會出現滿的情況，所以使用put或offer方法永 遠不會被阻塞，而且使用offer方法時，該方法永遠返回true。

2.阻塞佇列

    2.1 分類

1. ArrayBlockingQueue：一個由陣列結構組成的有界阻塞佇列。
2. LinkedBlockingQueue：一個由連結串列結構組成的有界阻塞佇列。
3. PriorityBlockingQueue：一個支援優先順序排序的無界阻塞佇列。
4. DelayQueue：一個使用優先順序佇列實現的無界阻塞佇列。
5. SynchronousQueue：一個不儲存元素的阻塞佇列。
6. LinkedTransferQueue：一個由連結串列結構組成的無界阻塞佇列。
7. LinkedBlockingDeque：一個由連結串列結構組成的雙向阻塞佇列。

    2.2 七種阻塞佇列使用詳解

1. ArrayBlockingQueue：是一個用陣列實現的有界阻塞佇列。此佇列按照先進先出的原則對元素進行排序。預設情況下不保證執行緒公平的訪問佇列，所謂公平訪問佇列是指阻塞的執行緒，可以按照阻塞的先後順序訪問佇列，即先阻塞執行緒先訪問佇列。非公平性是對先等待的執行緒是非公平的，當佇列可用時，阻塞的執行緒都可以爭奪訪問佇列的資格，有可能先阻塞的執行緒最後才訪問佇列。為了保證公平性，通常會降低吞吐量。訪問者的公平性是使用可重入鎖實現的。

   public class TestBlockingQueue {
   	public static void main(String[] args) {
   		int capacity=1000;//有界佇列元素容量，必須>=1
   		ArrayBlockingQueue<String> arr1=new ArrayBlockingQueue<String>(capacity);
   		ArrayBlockingQueue<String> arr2=new ArrayBlockingQueue<String>(capacity,true);//boolean值表示是否採用公平性原則
   		
   	}
   }

    

2. LinkedBlockingQueue：LinkedBlockingQueue是一個用連結串列實現的有界阻塞佇列。此佇列的預設和最大長度為 Integer.MAX_VALUE。此佇列按照先進先出的原則對元素進行排序。
3. PriorityBlockingQueue：是一個支援優先順序的無界阻塞佇列。預設情況下元素採取自然順序升序排列。也可以自定義類實現compareTo()方法來指定元素排序規則，或者初始化 PriorityBlockingQueue時，指定構造引數Comparator來對元素進行排序。需要注意的是不能保證 同優先順序元素的順序。
4. DelayQueue：DelayQueue是一個支援延時獲取元素的無界阻塞佇列。佇列使用PriorityQueue來實現。隊 列中的元素必須實現Delayed介面（可以參考ScheduledThreadPoolExecutor 裡ScheduledFutureTask類的實現），在建立元素時可以指定多久才能從佇列中獲取當前元素。 只有在延遲期滿時才能從佇列中提取元素。該阻塞佇列非常有用，比如可以設計快取系統，使用一個執行緒迴圈查詢 DelayQueue，一旦能從DelayQueue中獲取元素時，表示快取有效期到了；還可以做定時任務排程，使用DelayQueue儲存當天將會執行的任務和執行時間，一旦從 DelayQueue中獲取到任務就開始執行，比如TimerQueue就是使用DelayQueue實現的。
5. SynchronousQueue：SynchronousQueue是一個不儲存元素的阻塞佇列。每一個put操作必須等待一個take操作，否則不能繼續新增元素。它支援公平訪問佇列。預設情況下執行緒採用非公平性策略訪問佇列。使用以下構造方法可以建立公平性訪問的SynchronousQueue，如果設定為true，則等待的執行緒會採用先進先出的順序訪問佇列。可以將該佇列理解為一個傳球手，負責把生產者執行緒處理的資料直接傳遞給消費者執行緒。佇列本身並不儲存任何元素，非常適合傳遞性場景。
6. LinkedTransferQueue：LinkedTransferQueue是一個由連結串列結構組成的無界阻塞TransferQueue佇列。相對於其他阻塞佇列，LinkedTransferQueue多了tryTransfer和transfer方法。
   1. 使用transfer方法：如果當前有消費者正在等待接收元素（消費者使用take()方法或帶時間限制的poll()方法 時），transfer方法可以把生產者傳入的元素立transfer（傳輸）給消費者。如果沒有消費者在等 待接收元素，transfer方法會將元素存放在佇列的tail節點，並等到該元素被消費者消費了才返 回。
   2. tryTransfer方法：tryTransfer方法是用來試探生產者傳入的元素是否能直接傳給消費者。如果沒有消費者等 待接收元素，則返回false。和transfer方法的區別tryTransfer方法無論消費者是否接收，方法 立即返回，而transfer方法是必須等到消費者消費了才返回。 對於帶有時間限制的tryTransfer（E e，long timeout，TimeUnit unit）方法，試圖把生產者傳入 的元素直接傳給消費者，但是如果沒有消費者消費該元素則等待指定的時間再返回，如果超 時還沒消費元素，則返回false，如果在超時時間內消費了元素，則返回true。
7. LinkedBlockingDeque：LinkedBlockingDeque是一個由連結串列結構組成的雙向阻塞佇列。雙向佇列因為多了一個操作佇列的入口，在多執行緒同時入隊 時，也就減少了一半的競爭。相比其他的阻塞佇列，LinkedBlockingDeque多了addFirst、 addLast、offerFirst、offerLast、peekFirst和peekLast等方法，以First單詞結尾的方法，表示插入、 獲取（peek）或移除雙端佇列的第一個元素。以Last單詞結尾的方法，表示插入、獲取或移除雙 端佇列的最後一個元素。另外，插入方法add等同於addLast，移除方法remove等效於 removeFirst。但是take方法卻等同takeFirst

3.阻塞佇列實現原理

    JDK通過通知模式實現。所謂通知模式，就是當生產者往滿的佇列裡新增元素時會阻塞住生產者，當消費者消費了一個佇列中的元素後，會通知生產者當前佇列可用。通過檢視JDK原始碼 發現ArrayBlockingQueue使用了Condition來實現。也就是通過await/signal來實現。

 final Object[] items;
 final ReentrantLock lock;
 private final Condition notEmpty;
 private final Condition notFull;
 int count;
 public void put(E e) throws InterruptedException {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == items.length)
                notFull.await();
            enqueue(e);
        } finally {
            lock.unlock();
        }
 }
 public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == 0)
                notEmpty.await();
            return dequeue();
        } finally {
            lock.unlock();
        }
    }
 private void enqueue(E x) {
        // assert lock.getHoldCount() == 1;
        // assert items[putIndex] == null;
        final Object[] items = this.items;
        items[putIndex] = x;
        if (++putIndex == items.length)
            putIndex = 0;
        count++;
        notEmpty.signal();
    }
 private E dequeue() {
        // assert lock.getHoldCount() == 1;
        // assert items[takeIndex] != null;
        final Object[] items = this.items;
        @SuppressWarnings("unchecked")
        E x = (E) items[takeIndex];
        items[takeIndex] = null;
        if (++takeIndex == items.length)
            takeIndex = 0;
        count--;
        if (itrs != null)
            itrs.elementDequeued();
        notFull.signal();
        return x;
    }