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

/**
 * 因?yàn)槭顷?duì)列，用鏈表實(shí)現(xiàn)，所以頭尾指針肯定不可少。
 * */
transient Node<E> head;
private transient Node<E> last;
/**
 * 我們可以很清楚的看到，這里使用了2套ReentrantLock和對應(yīng)的condition條件等待隊(duì)列。
 * 目的也很明顯，讓生產(chǎn)者和消費(fèi)者并行。
 * */
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é)點(diǎn)。
    Node<E> node = new Node<E>(e);
    // 拿到生產(chǎn)者的鎖對象
    final ReentrantLock putLock = this.putLock;
    // 拿到全局計數(shù)器，注意這里用的是AtomicInteger，所以自增的原子性已經(jīng)保證。
    final AtomicInteger count = this.count;
    // 上的是可響應(yīng)中斷鎖。
    putLock.lockInterruptibly();
    try {
        // 如果當(dāng)前隊(duì)列已經(jīng)滿了，此時我們就要去阻塞，等待隊(duì)列被消費(fèi)，我們要被喚醒，醒來生產(chǎn)節(jié)點(diǎn)。
        while (count.get() == capacity) {
            // 進(jìn)入條件等待隊(duì)列阻塞。
            // 注意，只要阻塞，是會釋放鎖的，其他生產(chǎn)者線程可以搶到鎖。
            notFull.await();
        }
        // 插入到隊(duì)列尾部
        enqueue(node);
        // 因?yàn)椴迦肓斯?jié)點(diǎn)，所以全局計數(shù)需要+1
        // 但是這里請注意細(xì)節(jié)，getAndIncrement方法返回的是舊值。
        c = count.getAndIncrement();
        // 這里是一個很sao的點(diǎn)
        // 注意，這里只要當(dāng)前隊(duì)列沒滿，喚醒的是生產(chǎn)者的條件等待隊(duì)列。
        // 為什么要這么做？
        // 很簡單，首先需要考慮，生產(chǎn)者和消費(fèi)者是并發(fā)執(zhí)行了。 
        // 其次，只要隊(duì)列沒滿就能一直生產(chǎn)，那么隊(duì)列一旦滿了后，后來的線程就都去條件隊(duì)列阻塞，所以線程生產(chǎn)完一個節(jié)點(diǎn)就有必要去喚醒等待的同胞（不管有沒有同胞在阻塞，這是義務(wù)）
        if (c + 1 < capacity)
            // 喚醒條件等待隊(duì)列中頭部節(jié)點(diǎn)。
            notFull.signal();
    } finally {
        putLock.unlock();
    }
    // 這里也是一個很sao的點(diǎn)
    // 再次強(qiáng)調(diào)，getAndIncrement方法是返回的舊值
    // 所以當(dāng)前生產(chǎn)者如果生產(chǎn)的是第一個節(jié)點(diǎn)，那么c ==0
    // 而隊(duì)列中沒有節(jié)點(diǎn)，消費(fèi)者是要阻塞的
    // 也即，這里給隊(duì)列生產(chǎn)了一個節(jié)點(diǎn)，要喚醒消費(fèi)者去消費(fèi)節(jié)點(diǎn)。
    if (c == 0)
        signalNotEmpty();
}
// 插入到隊(duì)列尾部
// 因?yàn)镽eentrantLock保證了整體的原子性，所以這里細(xì)節(jié)部分不需要保證原子性了。
private void enqueue(Node<E> node) {
    // 插入到尾部
    last = last.next = node;
}

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