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; }  
    }  

然后，對于鏈表來說，肯定需要兩個(gè)變量來標(biāo)示頭和尾：

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

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

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

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

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

有兩個(gè)Condition很好理解，在ArrayBlockingQueue也是這樣做的。但是為什么需要兩個(gè)ReentrantLock呢？下面會(huì)慢慢道來。
讓我們來看看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;//入隊(duì)當(dāng)然用putLock
        putLock.lock();
        try {
            if (count.get() < capacity) {
                enqueue(e); //入隊(duì)
                c = count.getAndIncrement(); //隊(duì)長度+1
                if (c + 1 < capacity)
                    notFull.signal(); //隊(duì)列沒滿，當(dāng)然可以解鎖了
            }
        } finally {
            putLock.unlock();
        }
        if (c == 0)
            signalNotEmpty();//這個(gè)方法里發(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;出隊(duì)當(dāng)然用takeLock
        takeLock.lock();
        try {
            if (count.get() > 0) {
                x = dequeue();//出隊(duì)
                c = count.getAndDecrement();//隊(duì)長度-1
                if (c > 1)
                    notEmpty.signal();//隊(duì)列沒空，解鎖
            }
        } finally {
            takeLock.unlock();
        }
        if (c == capacity)
            signalNotFull();//這個(gè)方法里發(fā)出了notFull.signal();
        return x;
    }

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