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，且队列现有元素的大小由一个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();//这个方法里发出了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();//这个方法里发出了notFull.signal();
        return x;
    }

看看源代码发现和上面ArrayBlockingQueue的很类似，关键的问题在于：为什么要用两个ReentrantLockputLock和takeLock？
我们仔细想一下，入队操作其实操作的只有队尾引用last，并且没有牵涉到head。而出队操作其实只针对head，和last没有关系。那么就 是说入队和出队的操作完全不需要公用一把锁，所以就设计了两个锁，这样就实现了多个不同任务的线程入队的同时可以进行出队的操作，另一方面由于两个操作所 共同使用的count是AtomicInteger类型的，所以完全不用考虑计数器递增递减的问题。
另外，还有一点需要说明一下：await()和singal()这两个方法执行时都会检查当前线程是否是独占锁的当前线程，如果不是则抛出 java.lang.IllegalMonitorStateException异常。所以可以看到在源码中这两个方法都出现在Lock的保护块中。