阻塞隊列介紹

Queue接口

public interface Queue<E> extends Collection<E> {
    //添加一個元素，添加成功返回true, 如果隊列滿了，就會拋出異常
    boolean add(E e);
    //添加一個元素，添加成功返回true, 如果隊列滿了，返回false
    boolean offer(E e);
    //返回並刪除隊首元素，隊列爲空則拋出異常
    E remove();
    //返回並刪除隊首元素，隊列爲空則返回null
    E poll();
    //返回隊首元素，但不移除，隊列爲空則拋出異常
    E element();
    //獲取隊首元素，但不移除，隊列爲空則返回null
    E peek();
}

BlockingQueue接口

BlockingQueue 繼承了 Queue 接口，是隊列的一種。Queue 和 BlockingQueue 都是在 Java 5 中加入的。阻塞隊列（BlockingQueue）是一個在隊列基礎上又支持了兩個附加操作的隊列，常用解耦。兩個附加操作:

支持阻塞的插入方法put: 隊列滿時，隊列會阻塞插入元素的線程，直到隊列不滿。
支持阻塞的移除方法take: 隊列空時，獲取元素的線程會等待隊列變爲非空

BlockingQueue和JDK集合包中的Queue接口兼容，同時在其基礎上增加了阻塞功能。

入隊：

（1）offer(E e)：如果隊列沒滿，返回true，如果隊列已滿，返回false（不阻塞）

（2）offer(E e, long timeout, TimeUnit unit)：可以設置阻塞時間，如果隊列已滿，則進行阻塞。超過阻塞時間，則返回false

（3）put(E e)：隊列沒滿的時候是正常的插入，如果隊列已滿，則阻塞，直至隊列空出位置

出隊：

（1）poll()：如果有數據，出隊，如果沒有數據，返回null （不阻塞）

（2）poll(long timeout, TimeUnit unit)：可以設置阻塞時間，如果沒有數據，則阻塞，超過阻塞時間，則返回null

（3）take()：隊列裏有數據會正常取出數據並刪除；但是如果隊列裏無數據，則阻塞，直到隊列裏有數據

BlockingQueue常用方法示例

當隊列滿了無法添加元素，或者是隊列空了無法移除元素時：

拋出異常：add、remove、element
返回結果但不拋出異常：offer、poll、peek
阻塞：put、take

方法	拋出異常	返回特定值	阻塞	阻塞特定時間
入隊	add(e)	offer(e)	put(e)	offer(e, time, unit)
出隊	remove()	poll()	take()	poll(time, unit)
獲取隊首元素	element()	peek()	不支持	不支持

示例

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class BlockingQueueTest {

    public static void main(String[] args) {

        //addTest();
        //removeTest();
        //elementTest();
        //offerTest();
        //pollTest();
        //peekTest();
        //putTest();
        //takeTest();

    }

    /**
     * add 方法是往隊列裏添加一個元素，如果隊列滿了，就會拋出異常來提示隊列已滿。
     */
    private static void addTest() {
        BlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<Integer>(2);
        System.out.println(blockingQueue.add(1));
        System.out.println(blockingQueue.add(2));
        System.out.println(blockingQueue.add(3));
    }

    /**
     * remove 方法的作用是刪除元素並返回隊列的頭節點，如果刪除的隊列是空的， remove 方法就會拋出異常。
     */
    private static void removeTest() {
        ArrayBlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<Integer>(2);
        blockingQueue.add(1);
        blockingQueue.add(2);
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
    }

    /**
     * element 方法是返回隊列的頭部節點，但是並不刪除。如果隊列爲空，拋出異常
     */
    private static void elementTest() {
        ArrayBlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<Integer>(2);
        blockingQueue.element();
    }

    /**
     * offer 方法用來插入一個元素。如果添加成功會返回 true，而如果隊列已經滿了，返回false
     */
    private static void offerTest(){
        ArrayBlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<Integer>(2);
        System.out.println(blockingQueue.offer(1));
        System.out.println(blockingQueue.offer(2));
        System.out.println(blockingQueue.offer(3));
    }

    /**
     * poll 方法作用也是移除並返回隊列的頭節點。 如果隊列爲空，返回null
     */
    private static void pollTest() {
        ArrayBlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<Integer>(3);
        blockingQueue.offer(1);
        blockingQueue.offer(2);
        blockingQueue.offer(3);
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
    }

    /**
     * peek 方法返回隊列的頭元素但並不刪除。 如果隊列爲空，返回null
     */
    private static void peekTest() {
        ArrayBlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<Integer>(2);
        System.out.println(blockingQueue.peek());
    }

    /**
     * put 方法的作用是插入元素。如果隊列已滿就無法繼續插入,阻塞插入線程，直至隊列空出位置
     */
    private static void putTest(){
        BlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<Integer>(2);
        try {
            blockingQueue.put(1);
            blockingQueue.put(2);
            blockingQueue.put(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * take 方法的作用是獲取並移除隊列的頭結點。如果執隊列裏無數據，則阻塞，直到隊列裏有數據
     */
    private static void takeTest(){
        BlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<Integer>(2);
        try {
            blockingQueue.take();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

阻塞隊列特性

阻塞

阻塞隊列區別於其他類型的隊列的最主要的特點就是“阻塞”這兩個字，所以下面重點介紹阻塞功能：阻塞功能使得生產者和消費者兩端的能力得以平衡，當有任何一端速度過快時，阻塞隊列便會把過快的速度給降下來。實現阻塞最重要的兩個方法是 take 方法和 put 方法。

take 方法

take 方法的功能是獲取並移除隊列的頭結點，通常在隊列裏有數據的時候是可以正常移除的。可是一旦執行 take 方法的時候，隊列裏無數據，則阻塞，直到隊列裏有數據。一旦隊列裏有數據了，就會立刻解除阻塞狀態，並且取到數據。過程如圖所示：

put 方法

put 方法插入元素時，如果隊列沒有滿，那就和普通的插入一樣是正常的插入，但是如果隊列已滿，那麼就無法繼續插入，則阻塞，直到隊列裏有了空閒空間。如果後續隊列有了空閒空間，比如消費者消費了一個元素，那麼此時隊列就會解除阻塞狀態，並把需要添加的數據添加到隊列中。過程如圖所示：

思考：阻塞隊列是否有容量限制？

是否有界

阻塞隊列還有一個非常重要的屬性，那就是容量的大小，分爲有界和無界兩種。無界隊列意味着裏面可以容納非常多的元素，例如 LinkedBlockingQueue 的上限是 Integer.MAX_VALUE，是非常大的一個數，可以近似認爲是無限容量，因爲我們幾乎無法把這個容量裝滿。但是有的阻塞隊列是有界的，例如 ArrayBlockingQueue 如果容量滿了，也不會擴容，所以一旦滿了就無法再往裏放數據了。

應用場景

BlockingQueue 是線程安全的，我們在很多場景下都可以利用線程安全的隊列來優雅地解決我們業務自身的線程安全問題。比如說，使用生產者/消費者模式的時候，我們生產者只需要往隊列裏添加元素，而消費者只需要從隊列裏取出它們就可以了，如圖所示：

因爲阻塞隊列是線程安全的，所以生產者和消費者都可以是多線程的，不會發生線程安全問題。生產者/消費者直接使用線程安全的隊列就可以，而不需要自己去考慮更多的線程安全問題。這也就意味着，考慮鎖等線程安全問題的重任從“你”轉移到了“隊列”上，降低了我們開發的難度和工作量。

同時，隊列它還能起到一個隔離的作用。比如說我們開發一個銀行轉賬的程序，那麼生產者線程不需要關心具體的轉賬邏輯，只需要把轉賬任務，如賬戶和金額等信息放到隊列中就可以，而不需要去關心銀行這個類如何實現具體的轉賬業務。而作爲銀行這個類來講，它會去從隊列裏取出來將要執行的具體的任務，再去通過自己的各種方法來完成本次轉賬。這樣就實現了具體任務與執行任務類之間的解耦，任務被放在了阻塞隊列中，而負責放任務的線程是無法直接訪問到我們銀行具體實現轉賬操作的對象的，實現了隔離，提高了安全性。

常見阻塞隊列

BlockingQueue 接口的實現類都被放在了 juc 包中，它們的區別主要體現在存儲結構上或對元素操作上的不同，但是對於take與put操作的原理，卻是類似的。

隊列	描述
ArrayBlockingQueue	基於數組結構實現的一個有界阻塞隊列
LinkedBlockingQueue	基於鏈表結構實現的一個無界阻塞隊列，指定容量爲有界阻塞隊列
PriorityBlockingQueue	支持按優先級排序的無界阻塞隊列
DelayQueue	基於優先級隊列（PriorityBlockingQueue）實現的無界阻塞隊列
SynchronousQueue	不存儲元素的阻塞隊列
LinkedTransferQueue	基於鏈表結構實現的一個無界阻塞隊列
LinkedBlockingDeque	基於鏈表結構實現的一個雙端阻塞隊列

https://www.processon.com/view/link/618ce3941e0853689b0818e2

ArrayBlockingQueue

ArrayBlockingQueue是最典型的有界阻塞隊列，其內部是用數組存儲元素的，初始化時需要指定容量大小，利用 ReentrantLock 實現線程安全。

在生產者-消費者模型中使用時，如果生產速度和消費速度基本匹配的情況下，使用ArrayBlockingQueue是個不錯選擇；當如果生產速度遠遠大於消費速度，則會導致隊列填滿，大量生產線程被阻塞。

使用獨佔鎖ReentrantLock實現線程安全，入隊和出隊操作使用同一個鎖對象，也就是隻能有一個線程可以進行入隊或者出隊操作；這也就意味着生產者和消費者無法並行操作，在高併發場景下會成爲性能瓶頸。

ArrayBlockingQueue使用

BlockingQueue queue = new ArrayBlockingQueue(1024);
queue.put("1");   //向隊列中添加元素

ArrayBlockingQueue的原理

數據結構

利用了Lock鎖的Condition通知機制進行阻塞控制。

核心：一把鎖，兩個條件

//數據元素數組
final Object[] items;
//下一個待取出元素索引
int takeIndex;
//下一個待添加元素索引
int putIndex;
//元素個數
int count;
//內部鎖
final ReentrantLock lock;
//消費者
private final Condition notEmpty;
//生產者
private final Condition notFull;  

public ArrayBlockingQueue(int capacity) {
    this(capacity, false);
}
public ArrayBlockingQueue(int capacity, boolean fair) {
    ...
    lock = new ReentrantLock(fair); //公平，非公平
    notEmpty = lock.newCondition();
    notFull =  lock.newCondition();
}

入隊put方法

public void put(E e) throws InterruptedException {
	//檢查是否爲空
    checkNotNull(e);
    final ReentrantLock lock = this.lock;
    //加鎖，如果線程中斷拋出異常 
    lock.lockInterruptibly();
    try {
       //阻塞隊列已滿，則將生產者掛起，等待消費者喚醒
       //設計注意點： 用while不用if是爲了防止虛假喚醒
        while (count == items.length)
            notFull.await(); //隊列滿了，使用notFull等待（生產者阻塞）
        // 入隊
        enqueue(e);
    } finally {
        lock.unlock(); // 喚醒消費者線程
    }
}
    
private void enqueue(E x) {
    final Object[] items = this.items;
    //入隊   使用的putIndex
    items[putIndex] = x;
    if (++putIndex == items.length) 
        putIndex = 0;  //設計的精髓： 環形數組，putIndex指針到數組盡頭了，返回頭部
    count++;
    //notEmpty條件隊列轉同步隊列，準備喚醒消費者線程，因爲入隊了一個元素，肯定不爲空了
    notEmpty.signal();
}

出隊take方法

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    //加鎖，如果線程中斷拋出異常 
    lock.lockInterruptibly();
    try {
       //如果隊列爲空，則消費者掛起
        while (count == 0)
            notEmpty.await();
        //出隊
        return dequeue();
    } finally {
        lock.unlock();// 喚醒生產者線程
    }
}
private E dequeue() {
    final Object[] items = this.items;
    @SuppressWarnings("unchecked")
    E x = (E) items[takeIndex]; //取出takeIndex位置的元素
    items[takeIndex] = null;
    if (++takeIndex == items.length)
        takeIndex = 0; //設計的精髓： 環形數組，takeIndex 指針到數組盡頭了，返回頭部
    count--;
    if (itrs != null)
        itrs.elementDequeued();
    //notFull條件隊列轉同步隊列，準備喚醒生產者線程，此時隊列有空位
    notFull.signal();
    return x;
}

思考：爲什麼對數組操作要設計成雙指針？

LinkedBlockingQueue

LinkedBlockingQueue是一個基於鏈表實現的阻塞隊列，默認情況下，該阻塞隊列的大小爲Integer.MAX_VALUE，由於這個數值特別大，所以 LinkedBlockingQueue 也被稱作無界隊列，代表它幾乎沒有界限，隊列可以隨着元素的添加而動態增長，但是如果沒有剩餘內存，則隊列將拋出OOM錯誤。所以爲了避免隊列過大造成機器負載或者內存爆滿的情況出現，我們在使用的時候建議手動傳一個隊列的大小。

LinkedBlockingQueue內部由單鏈表實現，只能從head取元素，從tail添加元素。LinkedBlockingQueue採用兩把鎖的鎖分離技術實現入隊出隊互不阻塞，添加元素和獲取元素都有獨立的鎖，也就是說LinkedBlockingQueue是讀寫分離的，讀寫操作可以並行執行。

LinkedBlockingQueue使用

//指定隊列的大小創建有界隊列
BlockingQueue<Integer> boundedQueue = new LinkedBlockingQueue<>(100);
//無界隊列
BlockingQueue<Integer> unboundedQueue = new LinkedBlockingQueue<>();

LinkedBlockingQueue的原理

數據結構

// 容量,指定容量就是有界隊列
private final int capacity;
// 元素數量
private final AtomicInteger count = new AtomicInteger();
// 鏈表頭  本身是不存儲任何元素的，初始化時item指向null
transient Node<E> head;
// 鏈表尾
private transient Node<E> last;
// take鎖   鎖分離，提高效率
private final ReentrantLock takeLock = new ReentrantLock();
// notEmpty條件
// 當隊列無元素時，take鎖會阻塞在notEmpty條件上，等待其它線程喚醒
private final Condition notEmpty = takeLock.newCondition();
// put鎖
private final ReentrantLock putLock = new ReentrantLock();
// notFull條件
// 當隊列滿了時，put鎖會會阻塞在notFull上，等待其它線程喚醒
private final Condition notFull = putLock.newCondition();

//典型的單鏈表結構
static class Node<E> {
    E item;  //存儲元素
    Node<E> next;  //後繼節點    單鏈表結構
    Node(E x) { item = x; }
}

構造器

public LinkedBlockingQueue() {
    // 如果沒傳容量，就使用最大int值初始化其容量
    this(Integer.MAX_VALUE);
}

public LinkedBlockingQueue(int capacity) {
    if (capacity <= 0) throw new IllegalArgumentException();
    this.capacity = capacity;
    // 初始化head和last指針爲空值節點
    last = head = new Node<E>(null);
}

入隊put方法

public void put(E e) throws InterruptedException {    
    // 不允許null元素
    if (e == null) throw new NullPointerException();
    int c = -1;
    // 新建一個節點
    Node<E> node = new Node<E>(e);
    final ReentrantLock putLock = this.putLock;
    final AtomicInteger count = this.count;
    // 使用put鎖加鎖
    putLock.lockInterruptibly();
    try {
        // 如果隊列滿了，就阻塞在notFull上等待被其它線程喚醒（阻塞生產者線程）
        while (count.get() == capacity) {
            notFull.await();
        }  
        // 隊列不滿，就入隊
        enqueue(node);
        c = count.getAndIncrement();// 隊列長度加1，返回原值
        // 如果現隊列長度小於容量，notFull條件隊列轉同步隊列，準備喚醒一個阻塞在notFull條件上的線程(可以繼續入隊) 
        // 這裏爲啥要喚醒一下呢？
        // 因爲可能有很多線程阻塞在notFull這個條件上,而取元素時只有取之前隊列是滿的纔會喚醒notFull,此處不用等到取元素時才喚醒
        if (c + 1 < capacity)
            notFull.signal();
    } finally {
        putLock.unlock(); // 真正喚醒生產者線程
    }  
    // 如果原隊列長度爲0，現在加了一個元素後立即喚醒阻塞在notEmpty上的線程
    if (c == 0)
        signalNotEmpty();
}

private void enqueue(Node<E> node) { 
    // 直接加到last後面,last指向入隊元素
    last = last.next = node;
}    

private void signalNotEmpty() {
    final ReentrantLock takeLock = this.takeLock; 
    takeLock.lock();// 加take鎖
    try {  
        notEmpty.signal();// notEmpty條件隊列轉同步隊列，準備喚醒阻塞在notEmpty上的線程
    } finally {
        takeLock.unlock();  // 真正喚醒消費者線程
    }
    
}

出隊take方法

public E take() throws InterruptedException {
    E x;
    int c = -1;
    final AtomicInteger count = this.count;
    final ReentrantLock takeLock = this.takeLock;
    // 使用takeLock加鎖
    takeLock.lockInterruptibly();
    try {
        // 如果隊列無元素，則阻塞在notEmpty條件上（消費者線程阻塞）
        while (count.get() == 0) {
            notEmpty.await();
        }
        // 否則，出隊
        x = dequeue();
        c = count.getAndDecrement();//長度-1，返回原值
        if (c > 1)// 如果取之前隊列長度大於1，notEmpty條件隊列轉同步隊列，準備喚醒阻塞在notEmpty上的線程，原因與入隊同理
            notEmpty.signal();
    } finally {
        takeLock.unlock(); // 真正喚醒消費者線程
    }
    // 爲什麼隊列是滿的才喚醒阻塞在notFull上的線程呢？
    // 因爲喚醒是需要加putLock的，這是爲了減少鎖的次數,所以，這裏索性在放完元素就檢測一下，未滿就喚醒其它notFull上的線程,
    // 這也是鎖分離帶來的代價
    // 如果取之前隊列長度等於容量（已滿），則喚醒阻塞在notFull的線程
    if (c == capacity)
        signalNotFull();
    return x;
}
private E dequeue() {
     // head節點本身是不存儲任何元素的
    // 這裏把head刪除，並把head下一個節點作爲新的值
    // 並把其值置空，返回原來的值
    Node<E> h = head;
    Node<E> first = h.next;
    h.next = h; // 方便GC
    head = first;
    E x = first.item;
    first.item = null;
    return x;
}
private void signalNotFull() {
    final ReentrantLock putLock = this.putLock;
    putLock.lock();
    try {
        notFull.signal();// notFull條件隊列轉同步隊列，準備喚醒阻塞在notFull上的線程
    } finally {
        putLock.unlock(); // 解鎖，這纔會真正的喚醒生產者線程
    }
}

LinkedBlockingQueue與ArrayBlockingQueue

LinkedBlockingQueue是一個阻塞隊列，內部由兩個ReentrantLock來實現出入隊列的線程安全，由各自的Condition對象的await和signal來實現等待和喚醒功能。它和ArrayBlockingQueue的不同點在於：

隊列大小有所不同，ArrayBlockingQueue是有界的初始化必須指定大小，而LinkedBlockingQueue可以是有界的也可以是無界的(Integer.MAX_VALUE)，對於後者而言，當添加速度大於移除速度時，在無界的情況下，可能會造成內存溢出等問題。
數據存儲容器不同，ArrayBlockingQueue採用的是數組作爲數據存儲容器，而LinkedBlockingQueue採用的則是以Node節點作爲連接對象的鏈表。
由於ArrayBlockingQueue採用的是數組的存儲容器，因此在插入或刪除元素時不會產生或銷燬任何額外的對象實例，而LinkedBlockingQueue則會生成一個額外的Node對象。這可能在長時間內需要高效併發地處理大批量數據的時，對於GC可能存在較大影響。
兩者的實現隊列添加或移除的鎖不一樣，ArrayBlockingQueue實現的隊列中的鎖是沒有分離的，即添加操作和移除操作採用的同一個ReenterLock鎖，而LinkedBlockingQueue實現的隊列中的鎖是分離的，其添加採用的是putLock，移除採用的則是takeLock，這樣能大大提高隊列的吞吐量，也意味着在高併發的情況下生產者和消費者可以並行地操作隊列中的數據，以此來提高整個隊列的併發性能。

SynchronousQueue

SynchronousQueue是一個沒有數據緩衝的BlockingQueue，生產者線程對其的插入操作put必須等待消費者的移除操作take。

如圖所示，SynchronousQueue 最大的不同之處在於，它的容量爲 0，所以沒有一個地方來暫存元素，導致每次取數據都要先阻塞，直到有數據被放入；同理，每次放數據的時候也會阻塞，直到有消費者來取。

需要注意的是，SynchronousQueue 的容量不是 1 而是 0，因爲 SynchronousQueue 不需要去持有元素，它所做的就是直接傳遞（direct handoff）。由於每當需要傳遞的時候，SynchronousQueue 會把元素直接從生產者傳給消費者，在此期間並不需要做存儲，所以如果運用得當，它的效率是很高的。

應用場景

SynchronousQueue非常適合傳遞性場景做交換工作，生產者的線程和消費者的線程同步傳遞某些信息、事件或者任務。

SynchronousQueue的一個使用場景是在線程池裏。如果我們不確定來自生產者請求數量，但是這些請求需要很快的處理掉，那麼配合SynchronousQueue爲每個生產者請求分配一個消費線程是處理效率最高的辦法。Executors.newCachedThreadPool()就使用了SynchronousQueue，這個線程池根據需要（新任務到來時）創建新的線程，如果有空閒線程則會重複使用，線程空閒了60秒後會被回收。

SynchronousQueue使用

public class SynchronousQueueDemo {
    public static void main(String[] args) {
      //新建一個SynchronousQueue同步隊列
      final BlockingQueue<Integer> synchronousQueue = new SynchronousQueue<>(false);

      //啓動一個生產者線程插入對象
      SynchronousQueueProducer queueProducer = new SynchronousQueueProducer(synchronousQueue);
      new Thread(queueProducer).start();

      //啓動兩個消費者線程移除對象
      SynchronousQueueConsumer queueConsumer1 = new SynchronousQueueConsumer(synchronousQueue);
      new Thread(queueConsumer1).start();
    
      SynchronousQueueConsumer queueConsumer2 = new SynchronousQueueConsumer(synchronousQueue);
      new Thread(queueConsumer2).start();
    }
}

PriorityBlockingQueue

PriorityBlockingQueue是一個無界的基於數組的優先級阻塞隊列，數組的默認長度是11，雖然指定了數組的長度，但是可以無限的擴充，直到資源消耗盡爲止，每次出隊都返回優先級別最高的或者最低的元素。默認情況下元素採用自然順序升序排序，當然我們也可以通過構造函數來指定Comparator來對元素進行排序。需要注意的是PriorityBlockingQueue不能保證同優先級元素的順序。

優先級隊列PriorityQueue：隊列中每個元素都有一個優先級，出隊的時候，優先級最高的先出。

應用場景

電商搶購活動，會員級別高的用戶優先搶購到商品

銀行辦理業務，vip客戶插隊

PriorityBlockingQueue使用

//創建優先級阻塞隊列  Comparator爲null,自然排序
PriorityBlockingQueue<Integer> queue=new PriorityBlockingQueue<Integer>(5);
//自定義Comparator
PriorityBlockingQueue queue=new PriorityBlockingQueue<Integer>(
        5, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2-o1;
    }
}

思考：如何實現一個優先級隊列？

如何構造優先級隊列

使用普通線性數組(無序)來表示優先級隊列

執行插入操作時，直接將元素插入到數組末端，需要的成本爲O(1),
獲取優先級最高元素，我們需要遍歷整個線性隊列，匹配出優先級最高元素，需要的成本爲o(n)
刪除優先級最高元素，我們需要兩個步驟，第一找出優先級最高元素，第二步刪除優先級最高元素，然後將後面的元素依次遷移，填補空缺，需要的成本爲O(n)+O(n)=O(n)

使用一個按順序排列的有序向量實現優先級隊列

獲取優先級最高元素，O(1)
刪除優先級最高元素，O(1)
插入一個元素，需要兩個步驟，第一步我們需要找出要插的位置，這裏我們可以使用二分查找，成本爲O(logn)，第二步是插入元素之後，將其所有後繼進行後移操作，成本爲O(n)，所有總成本爲O(logn)+O(n)=O(n)

二叉堆

完全二叉樹：除了最後一行，其他行都滿的二叉樹，而且最後一行所有葉子節點都從左向右開始排序。

二叉堆：完全二叉樹的基礎上，加以一定的條件約束的一種特殊的二叉樹。根據約束條件的不同，二叉堆又可以分爲兩個類型：

大頂堆和小頂堆。

大頂堆（最大堆）：父結點的鍵值總是大於或等於任何一個子節點的鍵值；
小頂堆（最小堆）：父結點的鍵值總是小於或等於任何一個子節點的鍵值。

DelayQueue

DelayQueue 是一個支持延時獲取元素的阻塞隊列，內部採用優先隊列 PriorityQueue 存儲元素，同時元素必須實現 Delayed 接口；在創建元素時可以指定多久纔可以從隊列中獲取當前元素，只有在延遲期滿時才能從隊列中提取元素。延遲隊列的特點是：不是先進先出，而是會按照延遲時間的長短來排序，下一個即將執行的任務會排到隊列的最前面。

它是無界隊列，放入的元素必須實現 Delayed 接口，而 Delayed 接口又繼承了 Comparable 接口，所以自然就擁有了比較和排序的能力，代碼如下：

public interface Delayed extends Comparable<Delayed> {
    //getDelay 方法返回的是“還剩下多長的延遲時間纔會被執行”，
    //如果返回 0 或者負數則代表任務已過期。
    //元素會根據延遲時間的長短被放到隊列的不同位置，越靠近隊列頭代表越早過期。
    long getDelay(TimeUnit unit);
}

DelayQueue使用

public class DelayQueueDemo {

    static class Cache implements Runnable {

        private boolean stop = false;

        private Map<String, String> itemMap = new HashMap<>();

        private DelayQueue<CacheItem> delayQueue = new DelayQueue<>();

        public Cache () {
            // 開啓內部線程檢測是否過期
            new Thread(this).start();
        }

        /**
         * 添加緩存
         *
         * @param key
         * @param value
         * @param exprieTime&emsp;過期時間,單位秒
         */
        public void put (String key, String value, long exprieTime) {
            CacheItem cacheItem = new CacheItem(key, exprieTime);

            // 此處忽略添加重複 key 的處理
            delayQueue.add(cacheItem);
            itemMap.put(key, value);
        }

        public String get (String key) {
            return itemMap.get(key);
        }

        public void shutdown () {
            stop = true;
        }

        @Override
        public void run() {
            while (!stop) {
                CacheItem cacheItem = delayQueue.poll();
                if (cacheItem != null) {
                    // 元素過期, 從緩存中移除
                    itemMap.remove(cacheItem.getKey());
                    System.out.println("key : " + cacheItem.getKey() + " 過期並移除");
                }
            }

            System.out.println("cache stop");
        }
    }

    static class CacheItem implements Delayed {

        private String key;

        /**
         * 過期時間(單位秒)
         */
        private long exprieTime;

        private long currentTime;

        public CacheItem(String key, long exprieTime) {
            this.key = key;
            this.exprieTime = exprieTime;
            this.currentTime = System.currentTimeMillis();
        }

        @Override
        public long getDelay(TimeUnit unit) {
            // 計算剩餘的過期時間
            // 大於 0 說明未過期
            return exprieTime - TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis() - currentTime);
        }

        @Override
        public int compareTo(Delayed o) {
            // 過期時間長的放置在隊列尾部
            if (this.getDelay(TimeUnit.MICROSECONDS) > o.getDelay(TimeUnit.MICROSECONDS)) {
                return 1;
            }
            // 過期時間短的放置在隊列頭
            if (this.getDelay(TimeUnit.MICROSECONDS) < o.getDelay(TimeUnit.MICROSECONDS)) {
                return -1;
            }

            return 0;
        }

        public String getKey() {
            return key;
        }
    }

    public static void main(String[] args) throws InterruptedException {

        Cache cache = new Cache();

        // 添加緩存元素
        cache.put("a", "1", 5);
        cache.put("b", "2", 4);
        cache.put("c", "3", 3);

        while (true) {
            String a = cache.get("a");
            String b = cache.get("b");
            String c = cache.get("c");

            System.out.println("a : " + a + ", b : " + b + ", c : " + c);

            // 元素均過期後退出循環
            if (StringUtils.isEmpty(a) && StringUtils.isEmpty(b) && StringUtils.isEmpty(c)) {
                break;
            }

            TimeUnit.MILLISECONDS.sleep(1000);
        }

        cache.shutdown();
    }
}

DelayQueue的原理

數據結構

//用於保證隊列操作的線程安全
private final transient ReentrantLock lock = new ReentrantLock();
// 優先級隊列,存儲元素，用於保證延遲低的優先執行
private final PriorityQueue<E> q = new PriorityQueue<E>();
// 用於標記當前是否有線程在排隊（僅用於取元素時） leader 指向的是第一個從隊列獲取元素阻塞的線程
private Thread leader = null;
// 條件，用於表示現在是否有可取的元素   當新元素到達，或新線程可能需要成爲leader時被通知
private final Condition available = lock.newCondition();

public DelayQueue() {}
public DelayQueue(Collection<? extends E> c) {
    this.addAll(c);
}

入隊put方法

public void put(E e) {
    offer(e);
}
public boolean offer(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        // 入隊
        q.offer(e);
        if (q.peek() == e) {
            // 若入隊的元素位於隊列頭部，說明當前元素延遲最小
            // 將 leader 置空
            leader = null;
            // available條件隊列轉同步隊列,準備喚醒阻塞在available上的線程
            available.signal();
        }
        return true;
    } finally {
        lock.unlock(); // 解鎖，真正喚醒阻塞的線程
    }
}

出隊take方法

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        for (;;) {
            E first = q.peek();// 取出堆頂元素( 最早過期的元素，但是不彈出對象)   
            if (first == null)// 如果堆頂元素爲空，說明隊列中還沒有元素，直接阻塞等待
                available.await();//當前線程無限期等待，直到被喚醒，並且釋放鎖。
            else {
                long delay = first.getDelay(NANOSECONDS);// 堆頂元素的到期時間             
                if (delay <= 0)// 如果小於0說明已到期，直接調用poll()方法彈出堆頂元素
                    return q.poll();
                
                // 如果delay大於0 ，則下面要阻塞了
                // 將first置爲空方便gc
                first = null; 
                // 如果有線程爭搶的Leader線程，則進行無限期等待。
                if (leader != null)
                    available.await();
                else {
                    // 如果leader爲null，把當前線程賦值給它
                    Thread thisThread = Thread.currentThread();
                    leader = thisThread;
                    try {
                        // 等待剩餘等待時間
                        available.awaitNanos(delay);
                    } finally {
                        // 如果leader還是當前線程就把它置爲空，讓其它線程有機會獲取元素
                        if (leader == thisThread)
                            leader = null;
                    }
                }
            }
        }
    } finally {
        // 成功出隊後，如果leader爲空且堆頂還有元素，就喚醒下一個等待的線程
        if (leader == null && q.peek() != null)
            // available條件隊列轉同步隊列,準備喚醒阻塞在available上的線程
            available.signal();
        // 解鎖，真正喚醒阻塞的線程
        lock.unlock();
    }
}

當獲取元素時，先獲取到鎖對象。
獲取最早過期的元素，但是並不從隊列中彈出元素。
最早過期元素是否爲空，如果爲空則直接讓當前線程無限期等待狀態，並且讓出當前鎖對象。
如果最早過期的元素不爲空
獲取最早過期元素的剩餘過期時間，如果已經過期則直接返回當前元素
如果沒有過期，也就是說剩餘時間還存在，則先獲取Leader對象，如果Leader已經有線程在處理，則當前線程進行無限期等待，如果Leader爲空，則首先將Leader設置爲當前線程，並且讓當前線程等待剩餘時間。
最後將Leader線程設置爲空
如果Leader已經爲空，並且隊列有內容則喚醒一個等待的隊列。

如何選擇適合的阻塞隊列

線程池對於阻塞隊列的選擇

線程池有很多種，不同種類的線程池會根據自己的特點，來選擇適合自己的阻塞隊列。

FixedThreadPool（SingleThreadExecutor 同理）選取的是 LinkedBlockingQueue
CachedThreadPool 選取的是 SynchronousQueue
ScheduledThreadPool（SingleThreadScheduledExecutor同理）選取的是延遲隊列

選擇策略

通常我們可以從以下 5 個角度考慮，來選擇合適的阻塞隊列：

功能

第 1 個需要考慮的就是功能層面，比如是否需要阻塞隊列幫我們排序，如優先級排序、延遲執行等。如果有這個需要，我們就必須選擇類似於 PriorityBlockingQueue 之類的有排序能力的阻塞隊列。

容量

第 2 個需要考慮的是容量，或者說是否有存儲的要求，還是隻需要“直接傳遞”。在考慮這一點的時候，我們知道前面介紹的那幾種阻塞隊列，有的是容量固定的，如 ArrayBlockingQueue；有的默認是容量無限的，如 LinkedBlockingQueue；而有的裏面沒有任何容量，如 SynchronousQueue；而對於 DelayQueue 而言，它的容量固定就是 Integer.MAX_VALUE。所以不同阻塞隊列的容量是千差萬別的，我們需要根據任務數量來推算出合適的容量，從而去選取合適的 BlockingQueue。

能否擴容

第 3 個需要考慮的是能否擴容。因爲有時我們並不能在初始的時候很好的準確估計隊列的大小，因爲業務可能有高峯期、低谷期。如果一開始就固定一個容量，可能無法應對所有的情況，也是不合適的，有可能需要動態擴容。如果我們需要動態擴容的話，那麼就不能選擇 ArrayBlockingQueue ，因爲它的容量在創建時就確定了，無法擴容。相反，PriorityBlockingQueue 即使在指定了初始容量之後，後續如果有需要，也可以自動擴容。所以我們可以根據是否需要擴容來選取合適的隊列。

內存結構

第 4 個需要考慮的點就是內存結構。我們分析過 ArrayBlockingQueue 的源碼，看到了它的內部結構是“數組”的形式。和它不同的是，LinkedBlockingQueue 的內部是用鏈表實現的，所以這裏就需要我們考慮到，ArrayBlockingQueue 沒有鏈表所需要的“節點”，空間利用率更高。所以如果我們對性能有要求可以從內存的結構角度去考慮這個問題。

性能

第 5 點就是從性能的角度去考慮。比如 LinkedBlockingQueue 由於擁有兩把鎖，它的操作粒度更細，在併發程度高的時候，相對於只有一把鎖的 ArrayBlockingQueue 性能會更好。另外，SynchronousQueue 性能往往優於其他實現，因爲它只需要“直接傳遞”，而不需要存儲的過程。如果我們的場景需要直接傳遞的話，可以優先考慮 SynchronousQueue。

11-阻塞隊列BlockingQueue

阻塞隊列介紹

Queue接口

BlockingQueue接口

入隊：

出隊：

BlockingQueue常用方法示例

示例

阻塞隊列特性

阻塞

take 方法

put 方法

是否有界

應用場景

常見阻塞隊列

ArrayBlockingQueue

ArrayBlockingQueue使用

ArrayBlockingQueue的原理

入隊put方法

出隊take方法

LinkedBlockingQueue

LinkedBlockingQueue使用

LinkedBlockingQueue的原理

數據結構

構造器

入隊put方法

出隊take方法

LinkedBlockingQueue與ArrayBlockingQueue

SynchronousQueue

應用場景

SynchronousQueue使用

PriorityBlockingQueue

應用場景

PriorityBlockingQueue使用

如何構造優先級隊列

使用普通線性數組(無序)來表示優先級隊列

使用一個按順序排列的有序向量實現優先級隊列

二叉堆

DelayQueue

DelayQueue使用

DelayQueue的原理

數據結構

入隊put方法

出隊take方法

如何選擇適合的阻塞隊列

線程池對於阻塞隊列的選擇

選擇策略

功能

容量

能否擴容

內存結構

性能