public LinkedBlockingQueue(int capacity) {
    if (capacity <= 0) throw new IllegalArgumentException();
    this.capacity = capacity;
    // 初始化一個偽節(jié)點，讓head和last都指向這個偽節(jié)點
    // 為什么需要偽節(jié)點的存在？
    // 因為可以保證不會發(fā)生極端情況（假設沒有偽節(jié)點，并且只存在一個節(jié)點的情況下，生產者和消費者并發(fā)執(zhí)行就可能出現極端情況）
    last = head = new Node<E>(null);
}

/**
 * 因為是隊列，用鏈表實現，所以頭尾指針肯定不可少。
 * */
transient Node<E> head;
private transient Node<E> last;
/**
 * 我們可以很清楚的看到，這里使用了2套ReentrantLock和對應的condition條件等待隊列。
 * 目的也很明顯，讓生產者和消費者并行。
 * */
private final ReentrantLock takeLock = new ReentrantLock();
private final Condition notEmpty = takeLock.newCondition();
private final ReentrantLock putLock = new ReentrantLock();
private final Condition notFull = putLock.newCondition();

public void put(E e) throws InterruptedException {
    // 不能插入null
    if (e == null) throw new NullPointerException();
    int c = -1;
    // 創(chuàng)建插入的節(jié)點。
    Node<E> node = new Node<E>(e);
    // 拿到生產者的鎖對象
    final ReentrantLock putLock = this.putLock;
    // 拿到全局計數器，注意這里用的是AtomicInteger，所以自增的原子性已經保證。
    final AtomicInteger count = this.count;
    // 上的是可響應中斷鎖。
    putLock.lockInterruptibly();
    try {
        // 如果當前隊列已經滿了，此時我們就要去阻塞，等待隊列被消費，我們要被喚醒，醒來生產節(jié)點。
        while (count.get() == capacity) {
            // 進入條件等待隊列阻塞。
            // 注意，只要阻塞，是會釋放鎖的，其他生產者線程可以搶到鎖。
            notFull.await();
        }
        // 插入到隊列尾部
        enqueue(node);
        // 因為插入了節(jié)點，所以全局計數需要+1
        // 但是這里請注意細節(jié)，getAndIncrement方法返回的是舊值。
        c = count.getAndIncrement();
        // 這里是一個很sao的點
        // 注意，這里只要當前隊列沒滿，喚醒的是生產者的條件等待隊列。
        // 為什么要這么做？
        // 很簡單，首先需要考慮，生產者和消費者是并發(fā)執(zhí)行了。 
        // 其次，只要隊列沒滿就能一直生產，那么隊列一旦滿了后，后來的線程就都去條件隊列阻塞，所以線程生產完一個節(jié)點就有必要去喚醒等待的同胞（不管有沒有同胞在阻塞，這是義務）
        if (c + 1 < capacity)
            // 喚醒條件等待隊列中頭部節(jié)點。
            notFull.signal();
    } finally {
        putLock.unlock();
    }
    // 這里也是一個很sao的點
    // 再次強調，getAndIncrement方法是返回的舊值
    // 所以當前生產者如果生產的是第一個節(jié)點，那么c ==0
    // 而隊列中沒有節(jié)點，消費者是要阻塞的
    // 也即，這里給隊列生產了一個節(jié)點，要喚醒消費者去消費節(jié)點。
    if (c == 0)
        signalNotEmpty();
}
// 插入到隊列尾部
// 因為ReentrantLock保證了整體的原子性，所以這里細節(jié)部分不需要保證原子性了。
private void enqueue(Node<E> node) {
    // 插入到尾部
    last = last.next = node;
}

public E take() throws InterruptedException {
    E x;
    int c = -1;
    // 全局計數器
    final AtomicInteger count = this.count;
    // 消費者的鎖對象
    final ReentrantLock takeLock = this.takeLock;
    // 可響應中斷鎖。
    takeLock.lockInterruptibly();
    try {
        // 如果當前隊列中沒有節(jié)點，此時消費者需要去阻塞，因為不阻塞他只會浪費CPU性能，又消費不到節(jié)點。
        while (count.get() == 0) {
            // 去消費者的條件隊列阻塞。
            notEmpty.await();
        }
        // 醒來后，去消費節(jié)點。
        x = dequeue();
        // 給全局計數器-1，但是這里也要注意，返回的是舊值
        c = count.getAndDecrement();
        // 如果隊列中還有節(jié)點就喚醒其他消費者去消費節(jié)點。
        if (c > 1)
            notEmpty.signal();
    } finally {
        takeLock.unlock();
    }
    // 這里也是一個sao點
    // 請注意，這里的c是舊值，因為getAndDecrement返回的是舊值
    // 所以，如果當前消費線程消費節(jié)點之前隊列是滿的，當消費完畢后，我有必要去喚醒因為隊列滿了而阻塞等待的生產者，因為當前已經空出一個空間了。
    if (c == capacity)
        // 喚醒生產者
        signalNotFull();
    return x;
}
// 消費者消費節(jié)點
// 所以需要HelpGC 
// 不過這里要注意，head都是指向偽節(jié)點。
private E dequeue() {
    // 拿到頭節(jié)點，
    Node<E> h = head;
    // 拿到頭節(jié)點的next節(jié)點，next節(jié)點作為下一個head節(jié)點。
    // 因為head節(jié)點是指向偽節(jié)點，所以head.next節(jié)點就是當前要消費的節(jié)點。
    Node<E> first = h.next;
    // 將當前的頭結點的next指向自己。
    h.next = h; // help GC
    // 設置新的頭結點,也即把當前消費的節(jié)點做為下次的偽節(jié)點
    // head節(jié)點指向的都是偽節(jié)點
    head = first;
    // 拿到當前消費者想要的數據
    E x = first.item;
    first.item = null;
    return x;
}