1. 引言

Queue：基本上，一個隊列就是一個先入先出（FIFO）的數據結構，優先隊列除外其更具comparator或者comparable實現進行比較。
Queue接口與List、Set同一級別，都是繼承了Collection接口。LinkedList實現了Deque接口。
在併發隊列上JDK提供了兩套實現，一個是以ConcurrentLinkedQueue爲代表的高性能隊列非阻塞，一個是以BlockingQueue接口爲代表的阻塞隊列，無論哪種都繼承自Queue。

在最後兩節會深入當了解兩個queue的實現類，PriorityQueue和ConcurrentLinkedQueue。

Queue家族當繼承關係如下所示：

2. 阻塞隊列與非阻塞隊列

阻塞隊列與普通隊列的區別在於，當隊列是空的時，從隊列中獲取元素的操作將會被阻塞，或者當隊列是滿時，往隊列裏添加元素的操作會被阻塞。試圖從空的阻塞隊列中獲取元素的線程將會被阻塞，直到其他的線程往空的隊列插入新的元素。同樣，試圖往已滿的阻塞隊列中添加新元素的線程同樣也會被阻塞，直到其他的線程使隊列重新變得空閒起來，如從隊列中移除一個或者多個元素，或者完全清空隊列。

3. 子類簡述

3.1 未實現阻塞接口的

LinkedList : 實現了Deque接口，受限的隊列
PriorityQueue ：優先隊列，本質維護一個有序列表（內部維護一個最小堆的一維數組）。可自然排序亦可傳遞 comparator構造函數實現自定義排序。
ConcurrentLinkedQueue：基於鏈表線程安全的隊列。增加刪除O(1) 查找O(n)

3.2 實現阻塞接口的

實現blockqueue接口的五個阻塞隊列，其特點：當隊列滿或者空時，線程阻塞，直到到有空間或者插入元素時，才進行操作。

ArrayBlockingQueue：基於數組的有界隊列
LinkedBlockingQueue：基於鏈表的無界隊列
ProiporityBlockingQueue：基於優先次序的無界隊列
DelayQueue：基於時間優先級的隊列
SynchronousQueue：內部沒有容器的隊列較特別 --其獨有的線程一一配對通信機制

4. 基本操作方法

操作	拋出異常	返回特定值
入隊	add(e)	offer(e)——false
出隊	remove()	poll()——null
檢查	element()	peek()——null

另外在阻塞隊列中還有兩個阻塞方法：

    put 添加一個元素 如果隊列已滿 則阻塞
    take 刪除並返回隊列頭部元素 如果隊列爲空 則阻塞

5. PriorityQueue

5.1 簡介

優先級隊列，是0個或多個元素的集合，集合中的每個元素都有一個權重值，每次出隊都彈出優先級最大或最小的元素。一般來說，優先級隊列使用堆排序來實現。這裏簡單介紹下用到的知識，堆排序依賴於完全二叉樹。
若設二叉樹的深度爲h，除第h層外，其它各層 (1～h-1) 的結點數都達到最大個數，第h層所有的結點都連續集中在最左邊，這就是完全二叉樹。
在完全二叉樹之上，又引入一個新的概念，叫做最小/大堆，堆是一種經過排序的完全二叉樹，其中任一非終端節點的數據值均不大於（或不小於）其左子節點和右子節點的值。

5.2 源碼分析

5.2.1 主要屬性

    // 默認容量
    private static final int DEFAULT_INITIAL_CAPACITY = 11;
    // 存儲元素的地方
    transient Object[] queue; // non-private to simplify nested class access
    // 元素個數
    private int size = 0;
    // 比較器
    private final Comparator<? super E> comparator;
    // 修改次數
    transient int modCount = 0; // non-private to simplify nested class access

（1）默認容量是11；
（2）queue，元素存儲在數組中，這跟我們之前說的堆一般使用數組來存儲是一致的；
（3）comparator，比較器，在優先級隊列中，也有兩種方式比較元素，一種是元素的自然順序，一種是通過比較器來比較；
（4）modCount，修改次數，有這個屬性表示PriorityQueue也是fast-fail的，像ArrayList、HashMap中都有一個屬性叫modCount，每次對集合的修改這個值都會加1，在遍歷前記錄這個值到expectedModCount中，遍歷中檢查兩者是否一致，如果出現不一致就說明有修改，則拋出ConcurrentModificationException異常。

5.2.2 入列

入隊有兩個方法，add(E e)和offer(E e)，在PriorityQueue實現中兩者是一致的，add(E e)也是調用的offer(E e)。

    public boolean add(E e) {
        return offer(e);
    }


    public boolean offer(E e) {
        // 不支持null元素
        if (e == null)
            throw new NullPointerException();
        modCount++;
        // 取size
        int i = size;
        // 元素個數達到最大容量了，擴容
        if (i >= queue.length)
            grow(i + 1);
        // 元素個數加1
        size = i + 1;
        // 如果還沒有元素
        // 直接插入到數組第一個位置
        // 這裏跟我們之前講堆不一樣了
        // java裏面是從0開始的
        // 我們說的堆是從1開始的
        if (i == 0)
            queue[0] = e;
        else
            // 否則，插入元素到數組size的位置，也就是最後一個元素的下一位
            // 注意這裏的size不是數組大小，而是元素個數
            // 然後，再做自下而上的堆化
            siftUp(i, e);
        return true;
    }

    //自下而上堆化
    private void siftUp(int k, E x) {
        // 根據是否有比較器，使用不同的方法
        if (comparator != null)
            siftUpUsingComparator(k, x);
        else
            siftUpComparable(k, x);
    }

    @SuppressWarnings("unchecked")
    private void siftUpComparable(int k, E x) {
        Comparable<? super E> key = (Comparable<? super E>) x;
        while (k > 0) {
            // 找到父節點的位置
            // 因爲元素是從0開始的，所以減1之後再除以2
            int parent = (k - 1) >>> 1;
            // 父節點的值
            Object e = queue[parent];
            // 比較插入的元素與父節點的值
            // 如果比父節點大，則跳出循環
            // 否則交換位置
            if (key.compareTo((E) e) >= 0)
                break;
            // 與父節點交換位置
            queue[k] = e;
            // 現在插入的元素位置移到了父節點的位置
            // 繼續與父節點再比較
            k = parent;
        }
        // 最後找到應該插入的位置，放入元素，最終形成一個最小堆
        queue[k] = key;
    }

（1）入隊不允許null元素；
（2）如果數組不夠用了，先擴容；
（3）如果還沒有元素，就插入下標0的位置；
（4）如果有元素了，就插入到最後一個元素往後的一個位置（實際並沒有插入哈）；
（5）自下而上堆化，一直往上跟父節點比較；
（6）如果比父節點小，就與父節點交換位置，直到出現比父節點大爲止；
（7）由此可見，PriorityQueue是一個小頂堆。

5.2.3 擴容

    private void grow(int minCapacity) {
        // 舊容量
        int oldCapacity = queue.length;
        // Double size if small; else grow by 50%
        // 舊容量小於64時，容量翻倍
        // 舊容量大於等於64，容量只增加舊容量的一半
        int newCapacity = oldCapacity + ((oldCapacity < 64) ?
                                         (oldCapacity + 2) :
                                         (oldCapacity >> 1));
        // overflow-conscious code
        // 檢查是否溢出
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // 創建出一個新容量大小的新數組並把舊數組元素拷貝過去
        queue = Arrays.copyOf(queue, newCapacity);
    }

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

5.2.4 出隊

出隊有兩個方法，remove()和poll()，remove()也是調用的poll()，只是沒有元素的時候拋出異常。

    public E remove() {
        // 調用poll彈出隊首元素
        E x = poll();
        if (x != null)
            // 有元素就返回彈出的元素
            return x;
        else
            // 沒有元素就拋出異常
            throw new NoSuchElementException();
    }

    @SuppressWarnings("unchecked")
    public E poll() {
        // 如果size爲0，說明沒有元素
        if (size == 0)
            return null;
        // 彈出元素，元素個數減1
        int s = --size;
        modCount++;
        // 隊列首元素
        E result = (E) queue[0];
        // 隊列末元素
        E x = (E) queue[s];
        // 將隊列末元素刪除
        queue[s] = null;
        // 如果彈出元素後還有元素
        if (s != 0)
            // 將隊列末元素移到隊列首
            // 再做自上而下的堆化
            siftDown(0, x);
        // 返回彈出的元素
        return result;
    }

    //自上而下堆化
    private void siftDown(int k, E x) {
        // 根據是否有比較器，選擇不同的方法
        if (comparator != null)
            siftDownUsingComparator(k, x);
        else
            siftDownComparable(k, x);
    }

    @SuppressWarnings("unchecked")
    private void siftDownComparable(int k, E x) {
        Comparable<? super E> key = (Comparable<? super E>)x;
        // 只需要比較一半就行了，因爲葉子節點佔了一半的元素
        int half = size >>> 1;        // loop while a non-leaf
        while (k < half) {
            // 尋找子節點的位置，這裏加1是因爲元素從0號位置開始
            int child = (k << 1) + 1; // assume left child is least
            // 左子節點的值
            Object c = queue[child];
            // 右子節點的位置
            int right = child + 1;
            if (right < size &&
                ((Comparable<? super E>) c).compareTo((E) queue[right]) > 0)
                // 左右節點取其小者
                c = queue[child = right];
            // 如果比子節點都小，則結束
            if (key.compareTo((E) c) <= 0)
                break;
            // 如果比最小的子節點大，則交換位置
            queue[k] = c;
            // 指針移到最小子節點的位置繼續往下比較
            k = child;
        }
        // 找到正確的位置，放入元素
        queue[k] = key;
    }

（1）將隊列首元素彈出；
（2）將隊列末元素移到隊列首；
（3）自上而下堆化，一直往下與最小的子節點比較；
（4）如果比最小的子節點大，就交換位置，再繼續與最小的子節點比較；
（5）如果比最小的子節點小，就不用交換位置了，堆化結束；
（6）這就是堆中的刪除堆頂元素；

5.2.5 取隊列首元素

取隊首元素有兩個方法，element()和peek()，element()也是調用的peek()，只是沒取到元素時拋出異常。

    public E element() {
        E x = peek();
        if (x != null)
            return x;
        else
            throw new NoSuchElementException();
    }

    public E peek() {
        return (size == 0) ? null : (E) queue[0];
    }

5.2.6 優先隊列總結

（1）PriorityQueue是一個小頂堆；
（2）PriorityQueue是非線程安全的；
（3）PriorityQueue不是有序的，只有堆頂存儲着最小的元素；
（4）入隊就是堆的插入元素的實現；
（5）出隊就是堆的刪除元素的實現；

6. ConcurrentLinkedQueue

6.1 簡介

ConcurrentLinkedQueue只實現了Queue接口，並沒有實現BlockingQueue接口，所以它不是阻塞隊列，也不能用於線程池中，但是它是線程安全的，可用於多線程環境中。

6.2 源碼分析

6.2.1 主要屬性

    // 鏈表頭節點
    private transient volatile Node<E> head;
    // 鏈表尾節點
    private transient volatile Node<E> tail;

就這兩個主要屬性，一個頭節點，一個尾節點。

6.2.2 主要內部類

    private static class Node<E> {
        volatile E item;
        volatile Node<E> next;
    }

典型的單鏈表結構，非常純粹。

6.2.3 主要構造方法

    public ConcurrentLinkedQueue() {
        // 初始化頭尾節點
        head = tail = new Node<E>(null);
    }

    public ConcurrentLinkedQueue(Collection<? extends E> c) {
        Node<E> h = null, t = null;
        // 遍歷c，並把它元素全部添加到單鏈表中
        for (E e : c) {
            checkNotNull(e);
            Node<E> newNode = new Node<E>(e);
            if (h == null)
                h = t = newNode;
            else {
                t.lazySetNext(newNode);
                t = newNode;
            }
        }

        if (h == null)
            h = t = new Node<E>(null);
        head = h;
        tail = t;
    }

6.2.4 入隊

因爲它不是阻塞隊列，所以只有兩個入隊的方法，add(e)和offer(e)。因爲是無界隊列，所以add(e)方法也不用拋出異常了。

    public boolean add(E e) {
        return offer(e);
    }

    public boolean offer(E e) {
        // 不能添加空元素
        checkNotNull(e);
        // 新節點
        final Node<E> newNode = new Node<E>(e);
        // 入隊到鏈表尾
        for (Node<E> t = tail, p = t;;) {
            Node<E> q = p.next;
            // 如果沒有next，說明到鏈表尾部了，就入隊
            if (q == null) {
                // CAS更新p的next爲新節點
                // 如果成功了，就返回true
                // 如果不成功就重新取next重新嘗試
                if (p.casNext(null, newNode)) {
                    // 如果p不等於t，說明有其它線程先一步更新tail
                    // 也就不會走到q==null這個分支了
                    // p取到的可能是t後面的值
                    // 把tail原子更新爲新節點
                    if (p != t) // hop two nodes at a time
                        casTail(t, newNode);  // Failure is OK.
                    // 返回入隊成功
                    return true;
                }
            }
            else if (p == q)
                // 如果p的next等於p，說明p已經被刪除了（已經出隊了）
                // 重新設置p的值
                p = (t != (t = tail)) ? t : head;
            else
                // t後面還有值，重新設置p的值
                p = (p != t && t != (t = tail)) ? t : q;
        }
    }

入隊整個流程還是比較清晰的，這裏有個前提是出隊時會把出隊的那個節點的next設置爲節點本身。
（1）定位到鏈表尾部，嘗試把新節點放到後面；
（2）如果尾部變化了，則重新獲取尾部，再重試；

6.2.5 出隊

    public E remove() {
        E x = poll();
        if (x != null)
            return x;
        else
            throw new NoSuchElementException();
    }

    public E poll() {
        restartFromHead:
        for (;;) {
            // 嘗試彈出鏈表的頭節點
            for (Node<E> h = head, p = h, q;;) {
                E item = p.item;
                // 如果節點的值不爲空，並且將其更新爲null成功了
                if (item != null && p.casItem(item, null)) {
                    // 如果頭節點變了，則不會走到這個分支
                    // 會先走下面的分支拿到新的頭節點
                    // 這時候p就不等於h了，就更新頭節點
                    // 在updateHead()中會把head更新爲新節點
                    // 並讓head的next指向其自己
                    if (p != h) // hop two nodes at a time
                        updateHead(h, ((q = p.next) != null) ? q : p);
                    // 上面的casItem()成功，就可以返回出隊的元素了
                    return item;
                }
                // 下面三個分支說明頭節點變了
                // 且p的item肯定爲null
                else if ((q = p.next) == null) {
                    // 如果p的next爲空，說明隊列中沒有元素了
                    // 更新h爲p，也就是空元素的節點
                    updateHead(h, p);
                    // 返回null
                    return null;
                }
                else if (p == q)
                    // 如果p等於p的next，說明p已經出隊了，重試
                    continue restartFromHead;
                else
                    // 將p設置爲p的next
                    p = q;
            }
        }
    }

    // 更新頭節點的方法
    final void updateHead(Node<E> h, Node<E> p) {
        // 原子更新h爲p成功後，延遲更新h的next爲它自己
        // 這裏用延遲更新是安全的，因爲head節點已經變了
        // 只要入隊出隊的時候檢查head有沒有變化就行了，跟它的next關係不大
        if (h != p && casHead(h, p))
            h.lazySetNext(h);
    }

6.2.6 ConcurrentLinkedQueue總結：

（1）ConcurrentLinkedQueue不是阻塞隊列；
（2）ConcurrentLinkedQueue不能用在線程池中；
（3）ConcurrentLinkedQueue使用（CAS+自旋）更新頭尾節點控制出隊入隊操作；
ConcurrentLinkedQueue與LinkedBlockingQueue對比？
（1）兩者都是線程安全的隊列；
（2）兩者都可以實現取元素時隊列爲空直接返回null，後者的poll()方法可以實現此功能；
（3）前者全程無鎖，後者全部都是使用重入鎖控制的；
（4）前者效率較高，後者效率較低；
（5）前者無法實現如果隊列爲空等待元素到來的操作；
（6）前者是非阻塞隊列，後者是阻塞隊列；
（7）前者無法用在線程池中，後者可以；

轉自：
https://segmentfault.com/a/1190000019345930?utm_source=tag-newest
https://mp.weixin.qq.com/s/kpBAIRoMvqPzC-wfLELP3Q
https://www.jianshu.com/p/d9e8c8cd22af

little-motor

發佈了86 篇原創文章 · 獲贊 25 · 訪問量 6萬+

私信關注

詳解隊列Queue

文章目錄