聊聊併發（四）——阻塞佇列

一、概述

1、介紹

　　強烈建議讀者看這篇之前，先了解佇列相關知識，以及生產者與消費者模式。

　　concurrent 包中，BlockingQueue 很好的解決了多執行緒中，如何高效安全"傳輸"資料的問題。通過這些高效並且執行緒安全的佇列類，為快速搭建高質量的多執行緒程式帶來極大的便利。
　　阻塞佇列，首先它是一個佇列（先進先出），通過一個共享的佇列，可以使得資料從佇列的一端輸入，從另外一端輸出。

　　當佇列是空的，從佇列中獲取元素的操作將會被阻塞。
　　當佇列是滿的，從佇列中新增元素的操作將會被阻塞。

　　api文件：https://www.matools.com/api/java8

2、為什麼需要阻塞佇列？

　　理由：需要結合生產者與消費者來說。
　　好處就是不需要關心什麼時候需要阻塞執行緒，什麼時候需要喚醒執行緒，因為這一切BlockingQueue 都一手包辦了。在 concurrent 包釋出之前，多執行緒環境下，程式設計師必須自己控制這些細節，尤其還要兼顧效率和執行緒安全，這給程式帶來不小的複雜度。

3、相關API

　　BlockingQueue 核心方法

方法型別	丟擲異常	特殊值	阻塞	超時
插入	add(e)	offer(e)	put(e)	offer(e,time,unit)
刪除	remove()	poll()	take()	poll(time,unit)
檢查	element()	peek()	不可用	不可用

 

丟擲異常	隊滿時：再插入元素會丟擲異常 隊空時：再刪除元素會丟擲異常
特殊值	插入：成功 true，失敗false 刪除：成功，返回隊元素。沒有就返回null
阻塞	隊滿時：再 put 元素會一直阻塞，或響應中斷退出。 隊空時：再 take 元素會一直阻塞。
超時	隊滿時：再插入元素，會阻塞一定時間，超時後退出。 隊空時：再刪除元素，會阻塞一定時間，超時後退出。

4、作用

　　API文件中明確提出，阻塞佇列被設計主要就是用於生產者與消費者模式。這樣並不需要用到Lock 或 synchronized 以及等待喚醒機制。
　　而是僅僅用到了阻塞佇列以及原子變數類，就可以實現生產者消費者模型。不用程式設計師關心具體的加鎖解鎖過程，而是更關注具體的業務邏輯。

二、分類

1、ArrayBlockingQueue

　　由陣列結構組成的有界阻塞佇列。
　　基於陣列的阻塞佇列，在 ArrayBlockingQueue 內部，維護了一個定長陣列，以便快取佇列中的資料物件。這是一個常用的阻塞佇列，除了一個定長陣列外，ArrayBlockingQueue 內部還儲存著兩個整形變數，分別標識著佇列的頭部和尾部在陣列中的位置。
　　ArrayBlockingQueue 在生產者放入資料和消費者獲取資料，都是共用同一個鎖物件，由此也意味著兩者無法真正並行執行，這點尤其不同於LinkedBlockingQueue。
按照實現原理來分析，ArrayBlockingQueue 完全可以採用分離鎖，從而實現生產者和消費者操作的完全並行執行。Doug Lea 之所以沒這樣去做，也許是因為 ArrayBlockingQueue 的資料寫入和獲取操作已經足夠輕巧，以至於引入獨立的鎖機制，除了給程式碼帶來額外的複雜性外，其在效能上完全佔不到任何便宜。 ArrayBlockingQueue 和 LinkedBlockingQueue 間還有一個明顯的不同之處在於，前者在插入或刪除元素時不會產生或銷燬任何額外的物件例項，而後者則會生成一個額外的 Node 物件。這在長時間內需要高效併發地處理大批量資料的系統中，其對於 GC 的影響還是存在一定的區別。而在建立 ArrayBlockingQueue 時，還可以控制物件的內部鎖是否採用公平鎖，預設採用非公平鎖。

2、LinkedBlockingQueue

　　由連結串列結構組成的有界（大小預設值為integer.MAX_VALUE）阻塞佇列。
　　基於連結串列的阻塞佇列，同 ArrayBlockingQueue 類似，其內部也維持著一個資料緩衝佇列（該佇列由一個連結串列構成），當生產者往佇列中放入一個資料時，佇列會從生產者手中獲取資料，並快取在佇列內部，而生產者立即返回；只有當佇列緩衝區達到最大值快取容量時，才會阻塞生產者佇列，直到消費者從佇列中消費掉一份資料，生產者執行緒會被喚醒，反之對於消費者這端的處理也基於同樣的原理。

　　LinkedBlockingQueue 之所以能夠高效的處理併發資料，還因為其對於生產者端和消費者端分別採用了獨立的鎖來控制資料同步，這也意味著在高併發的情況下生產者和消費者可以並行地操作佇列中的資料，以此來提高整個佇列的併發效能。

3、DelayQueue

　　使用優先順序佇列實現的延遲無界阻塞佇列。

　　DelayQueue 中的元素只有當其指定的延遲時間到了，才能夠從佇列中獲取到該元素。DelayQueue 是一個沒有大小限制的佇列，因此往佇列中插入資料的操作（生產者）永遠不會被阻塞，而只有獲取資料的操作（消費者）才會被阻塞。

4、PriorityBlockingQueue

　　支援優先順序排序的無界阻塞佇列。
　　基於優先順序的阻塞佇列（優先順序的判斷通過建構函式傳入的 Compator 物件來決定），但需要注意的是 PriorityBlockingQueue 並不會阻塞生產者，而只會在沒有可消費的資料時，阻塞消費者。因此使用的時候要特別注意，生產者生產資料的速度絕對不能快於消費者消費資料的速度，否則時間一長，會最終耗盡所有的可用堆記憶體空間。在實現 PriorityBlockingQueue 時，內部控制執行緒同步的鎖採用的是非公平鎖。

5、SynchronousQueue

　　不儲存元素的阻塞佇列，即單個元素的佇列。單個插入操作必須等到另一個執行緒呼叫移除操作，否則插入操作一直處於阻塞狀態。
　　一種無緩衝的等待佇列，類似於無中介的直接交易，有點像原始社會中的生產者和消費者，生產者拿著產品去集市銷售給產品的最終消費者，而消費者必須親自去集市找到所要商品的直接生產者，如果一方沒有找到合適的目標，那麼大家都在集市等待。
　　相對於有緩衝的 BlockingQueue 來說，少了一箇中間經銷商的環節（緩衝區）。如果有經銷商，生產者直接把產品批發給經銷商，而無需在意經銷商最終會將這些產品賣給哪些消費者，由於經銷商可以庫存一部分商品，因此相對於直接交易模式，總體來說採用中間經銷商的模式會吞吐量高一些（可以批量買賣）。
　　但另一方面，又因為經銷商的引入，使得產品從生產者到消費者中間增加了額外的交易環節，單個產品的及時響應效能可能會降低。宣告一個 SynchronousQueue 有兩種不同的方式，它們之間有著不太一樣的行為。

　　原始碼示例：構造器

/**
 * Creates a {@code SynchronousQueue} with nonfair access policy.
 */
public SynchronousQueue() {
    this(false);
}

/**
 * Creates a {@code SynchronousQueue} with the specified fairness policy.
 *
 * @param fair if true, waiting threads contend in FIFO order for
 *        access; otherwise the order is unspecified.
 */
 // 如果fair是true,那麼等待的執行緒通過一個FIFO保證順序;否則順序是不明確的
public SynchronousQueue(boolean fair) {
    transferer = fair ? new TransferQueue<E>() : new TransferStack<E>();
}

　　公平模式和非公平模式的區別：
　　公平模式：SynchronousQueue 會採用公平鎖，並配合一個 FIFO 佇列來阻塞多餘的生產者和消費者，從而體現整體的公平策略。
　　非公平模式（預設）：SynchronousQueue 採用非公平鎖，同時配合一個 LIFO 棧來管理多餘的生產者和消費者。
　　後一種模式，如果生產者和消費者的處理速度有差距，則很容易出現飢渴的情況，即可能有某些生產者或消費者的資料永遠得不到處理。

6、LinkedTransferQueue

　　由連結串列組成的無界阻塞佇列。一個由連結串列結構組成的無界阻塞 TransferQueue 佇列。
　　相對於其他阻塞佇列，LinkedTransferQueue 多了 tryTransfer 和 transfer 方法。LinkedTransferQueue 採用一種預佔模式。意思就是消費者執行緒取元素時，如果佇列不為空，則直接取走資料，若佇列為空，那就生成一個節點（節點元素為 null）入隊，然後消費者執行緒被等待在這個節點上，後面生產者執行緒入隊時發現有一個元素為 null 的節點，生產者執行緒就不入隊了，直接就將元素填充到該節點，並喚醒該節點等待的執行緒，被喚醒的消費者執行緒取走元素，從呼叫的方法返回。

7、LinkedBlockingDeque

　　由連結串列組成的雙向阻塞佇列。
　　LinkedBlockingDeque 是一個由連結串列結構組成的雙向阻塞佇列，即可以從佇列的兩端插入和移除元素。對於一些指定的操作，在插入或者獲取佇列元素時如果佇列狀態不允許該操作，可能會阻塞該執行緒直到佇列狀態變更為允許操作，這裡的阻塞一般有兩種情況
　　插入元素時：如果當前佇列已滿將會進入阻塞狀態，一直等到佇列有空的位置時再將該元素插入。該操作可以通過設定超時引數，超時後返回 false 表示操作失敗，也可以不設定超時引數一直阻塞，中斷後丟擲 InterruptedException 異常。
　　讀取元素時：如果當前佇列為空會阻塞，直到佇列不為空然後返回元素，同樣可以通過設定超時引數。

三、SynchronousQueue

　　沒有容量，與其他BlockingQueue不同，SychronousQueue是一個不儲存元素的BlockingQueue，每一個put操作必須要等待一個take操作，否則不能繼續新增元素，反之亦然。
　　程式碼示例：

public class SynchronousQueueDemo {
    public static void main(String[] args) {
        BlockingQueue<Integer> blockingQueue = new SynchronousQueue<>();

        // AAA執行緒主要用來對阻塞佇列進行put操作
        new Thread(() -> {
            try {
                System.out.println(Thread.currentThread().getName() + "\t" + "put 1");
                blockingQueue.put(1);
                System.out.println(Thread.currentThread().getName() + "\t" + "put 2");
                blockingQueue.put(2);
                System.out.println(Thread.currentThread().getName() + "\t" + "put 3");
                blockingQueue.put(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "AAA").start();

        // BBB執行緒主要從阻塞佇列當中進行take操作
        new Thread(() -> {
            try {
                Thread.sleep(5000);
                System.out.println(Thread.currentThread().getName() + "\t take:" + blockingQueue.take());
                Thread.sleep(5000);
                System.out.println(Thread.currentThread().getName() + "\t take:" + blockingQueue.take());
                Thread.sleep(5000);
                System.out.println(Thread.currentThread().getName() + "\t take:" + blockingQueue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "BBB").start();
    }
}

　　參考文件：https://www.matools.com/api/java8