LinkedBlockingQueue原理分析---基於JDK8

1.常用的阻塞佇列 

其中LinkedBlockingQueue和ArrayBlockingQueue比較起來,它們背後所用的資料結構不一樣,導致LinkedBlockingQueue的資料吞吐量要大於ArrayBlockingQueue,但線上程數量很大時其效能的可預見性低於ArrayBlockingQueue

2.LinkedBlockingQueue原理

1. 基於連結串列實現，執行緒安全的阻塞佇列。
2. 使用鎖分離方式提高併發，雙鎖（ReentrantLock）：takeLock、putLock，允許讀寫並行，remove(e)和contain()、clear()需要同時獲取2個鎖。
3. FIFO先進先出模式。
4. 在大部分併發場景下，LinkedBlockingQueue的吞吐量比ArrayBlockingQueue更好，雙鎖，入隊和出隊同時進行
5. 根據構造傳入的容量大小決定有界還是無界，預設不傳的話，大小Integer.Max
   

3.LinkedBlockingQueue的幾個關鍵屬性

static class Node<E> {
        E item;

        /**後繼節點
         */
        Node<E> next;

        Node(E x) { item = x; }
    }

    /** 佇列容量，預設最大，可指定大小 */
    private final int capacity;

    /** 當前容量 */
    private final AtomicInteger count = new AtomicInteger();

    /**
     * 頭節點.
     * Invariant: head.item == null
     */
    transient Node<E> head;

    /**
     * 尾節點.
     * Invariant: last.next == null
     */
    private transient Node<E> last;

    /** 定義的出隊和入隊分離鎖,2個佇列空和滿的出隊和入隊條件 Lock held by take, poll, etc */
    private final ReentrantLock takeLock = new ReentrantLock();

    /** Wait queue for waiting takes */
    private final Condition notEmpty = takeLock.newCondition();

    /** Lock held by put, offer, etc */
    private final ReentrantLock putLock = new ReentrantLock();

    /** Wait queue for waiting puts */
    private final Condition notFull = putLock.newCondition();

public LinkedBlockingQueue() {
        this(Integer.MAX_VALUE);
    }

    /**
     * 指定有界大小，同時初始化head和tail節點
     *
     * @param capacity the capacity of this queue
     * @throws IllegalArgumentException if {@code capacity} is not greater
     *         than zero
     */
    public LinkedBlockingQueue(int capacity) {
        if (capacity <= 0) throw new IllegalArgumentException();
        this.capacity = capacity;
        last = head = new Node<E>(null);
    }

    /**
     * 遍歷集合元素，放到佇列進行初始化  ---  無界佇列
     *
     * @param c the collection of elements to initially contain
     * @throws NullPointerException if the specified collection or any
     *         of its elements are null
     */
    public LinkedBlockingQueue(Collection<? extends E> c) {
        this(Integer.MAX_VALUE);
        final ReentrantLock putLock = this.putLock;
        putLock.lock(); // Never contended, but necessary for visibility
        try {
            int n = 0;
            for (E e : c) {
                if (e == null)
                    throw new NullPointerException();
                if (n == capacity)
                    throw new IllegalStateException("Queue full");
                enqueue(new Node<E>(e));
                ++n;
            }
            count.set(n);
        } finally {
            putLock.unlock();
        }
    }

4.BlockingQueue原始碼分析

    //入隊，將元素新增到對尾等價  last.next = node; last = last.next
    private void enqueue(Node<E> node) {
        last = last.next = node;
    }

    /**
     * 出隊，從頭部出
     *
     * @return the node
     */
    private E dequeue() {
        // assert takeLock.isHeldByCurrentThread();
        // assert head.item == null;
        Node<E> h = head;
        Node<E> first = h.next;
        h.next = h; // help GC
        head = first;
        E x = first.item;
        first.item = null;
        return x;
    }

// 佇列已滿:false  
public boolean offer(E e) {  
    if (e == null) throw new NullPointerException();  
    final AtomicInteger count = this.count;  
    if (count.get() == capacity) // 佇列容量達到最大值，新增失敗  
        return false;  
    int c = -1;  
    Node<E> node = new Node<E>(e);  
    final ReentrantLock putLock = this.putLock;  
    putLock.lock(); // 獲取插入鎖putLock  
    try {  
        if (count.get() < capacity) { // 加鎖後再次判斷佇列是否已滿  
            enqueue(node); // 入隊  
            c = count.getAndIncrement(); // 返回Inc之前的值  
            if (c + 1 < capacity) // 插入節點後佇列未滿  
                notFull.signal(); // 喚醒notFull上的等待執行緒  
        }  
    } finally {  
        putLock.unlock(); // 釋放插入鎖  
    }  
    if (c == 0)  
        signalNotEmpty(); // 如果offer前佇列為空，則喚醒notEmpty上的等待執行緒  
    return c >= 0;  
}  

long nanos = unit.toNanos(timeout);  //將指定的時間長度轉換為毫秒來進行處理  
while (count.get() == capacity) {  
    if (nanos <= 0) // 等待的剩餘時間小於等於0，那麼直接返回false  
        return false;  
    nanos = notFull.awaitNanos(nanos); // 最多等待時間（納秒）  
}  

//插入節點：\n執行緒入隊操作前會獲取putLock鎖，插入資料完畢後釋放；
佇列未滿將新建Node節點，新增到佇列末尾；
佇列已滿則阻塞執行緒（notFull.await()）或返回false；若執行緒B取出資料，則會呼叫notFull.signal()喚醒notFull上的等待執行緒（執行緒A繼續插資料）。
若入隊前佇列為空，則喚醒notEmpty上等待的獲取資料的執行緒

// 一直阻塞直到插入成功  
public void put(E e) throws InterruptedException {  
    if (e == null) throw new NullPointerException();  
    // Note: convention in all put/take/etc is to preset local var  
    // holding count negative to indicate failure unless set.  
    int c = -1;  
    Node<E> node = new Node<E>(e);  
    final ReentrantLock putLock = this.putLock;  
    final AtomicInteger count = this.count;  
 // 可中斷的鎖獲取操作（優先考慮響應中斷），如果執行緒由於獲取鎖而處於Blocked狀態時，執行緒將被中斷而不再繼續等待（throws InterruptedException），可避免死鎖。  
    putLock.lockInterruptibly();  
    try {  
        /* 
         * Note that count is used in wait guard even though it is 
         * not protected by lock. This works because count can 
         * only decrease at this point (all other puts are shut 
         * out by lock), and we (or some other waiting put) are 
         * signalled if it ever changes from capacity. Similarly 
         * for all other uses of count in other wait guards. 
         */  
// 佇列若滿執行緒將處於等待狀態。while迴圈可避免“偽喚醒”（執行緒被喚醒時佇列大小依舊達到最大值）  
        while (count.get() == capacity) {  
            notFull.await(); // notFull：入隊條件  
        }  
        enqueue(node); // 將node連結到佇列尾部  
        c = count.getAndIncrement(); // 元素入隊後佇列元素總和  
        if (c + 1 < capacity) // 佇列未滿  
            notFull.signal(); // 喚醒其他執行入佇列的執行緒  
    } finally {  
        putLock.unlock(); // 釋放鎖  
    }  
// c=0說明佇列之前為空，出佇列執行緒均處於等待狀態。新增一個元素後，佇列已不為空，於是喚醒等待獲取元素的執行緒  
    if (c == 0)  
        signalNotEmpty();  
}  

參考、感謝：

http://blog.csdn.net/u010887744/article/details/73010691