static class Node<E> {  
        /** The item, volatile to ensure barrier separating write and read */  
        volatile E item;  
        Node<E> next;  
        Node(E x) { item = x; }  
    }  

然后，對于鏈表來說，肯定需要兩個變量來標示頭和尾：

    /** 頭指針 */  
    private transient Node<E> head;  //head.next是隊列的頭元素
    /** 尾指針 */  
    private transient Node<E> last;  //last.next是null

么，對于入隊和出隊就很自然能理解了：

    private void enqueue(E x) {  
        last = last.next = new Node<E>(x);  //入隊是為last再找個下家
    }  
 
    private E dequeue() {  
        Node<E> first = head.next;  //出隊是把head.next取出來，然后將head向后移一位
        head = first;  
        E x = first.item;  
        first.item = null;  
        return x;  
    }  

另外，LinkedBlockingQueue相對于ArrayBlockingQueue還有不同是，有兩個ReentrantLock，且隊列現(xiàn)有元素的大小由一個AtomicInteger對象標示。
注：AtomicInteger類是以原子的方式操作整型變量。

    private final AtomicInteger count = new AtomicInteger(0);
    /** 用于讀取的獨占鎖*/  
    private final ReentrantLock takeLock = new ReentrantLock();  
    /** 隊列是否為空的條件 */  
    private final Condition notEmpty = takeLock.newCondition();  
    /** 用于寫入的獨占鎖 */  
    private final ReentrantLock putLock = new ReentrantLock();  
    /** 隊列是否已滿的條件 */  
    private final Condition notFull = putLock.newCondition();

有兩個Condition很好理解，在ArrayBlockingQueue也是這樣做的。但是為什么需要兩個ReentrantLock呢？下面會慢慢道來。
讓我們來看看offer和poll方法的代碼：

    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;
        final ReentrantLock putLock = this.putLock;//入隊當然用putLock
        putLock.lock();
        try {
            if (count.get() < capacity) {
                enqueue(e); //入隊
                c = count.getAndIncrement(); //隊長度+1
                if (c + 1 < capacity)
                    notFull.signal(); //隊列沒滿，當然可以解鎖了
            }
        } finally {
            putLock.unlock();
        }
        if (c == 0)
            signalNotEmpty();//這個方法里發(fā)出了notEmpty.signal();
        return c >= 0;
    }

   public E poll() {
        final AtomicInteger count = this.count;
        if (count.get() == 0)
            return null;
        E x = null;
        int c = -1;
        final ReentrantLock takeLock = this.takeLock;出隊當然用takeLock
        takeLock.lock();
        try {
            if (count.get() > 0) {
                x = dequeue();//出隊
                c = count.getAndDecrement();//隊長度-1
                if (c > 1)
                    notEmpty.signal();//隊列沒空，解鎖
            }
        } finally {
            takeLock.unlock();
        }
        if (c == capacity)
            signalNotFull();//這個方法里發(fā)出了notFull.signal();
        return x;
    }

看看源代碼發(fā)現(xiàn)和上面ArrayBlockingQueue的很類似，關鍵的問題在于：為什么要用兩個ReentrantLockputLock和takeLock？
我們仔細想一下，入隊操作其實操作的只有隊尾引用last，并且沒有牽涉到head。而出隊操作其實只針對head，和last沒有關系。那么就 是說入隊和出隊的操作完全不需要公用一把鎖，所以就設計了兩個鎖，這樣就實現(xiàn)了多個不同任務的線程入隊的同時可以進行出隊的操作，另一方面由于兩個操作所 共同使用的count是AtomicInteger類型的，所以完全不用考慮計數(shù)器遞增遞減的問題。
另外，還有一點需要說明一下：await()和singal()這兩個方法執(zhí)行時都會檢查當前線程是否是獨占鎖的當前線程，如果不是則拋出 java.lang.IllegalMonitorStateException異常。所以可以看到在源碼中這兩個方法都出現(xiàn)在Lock的保護塊中。