/**
 * 鏈表中的節(jié)點類
 */
static class Node<E> {
    //節(jié)點中的元素
    E item;
    //下一個節(jié)點
    Node<E> next;
    Node(E x) { item = x; }
}
/** 鏈表隊列的容量大小,如果沒有指定則使用Integer最大值 */
private final int capacity;
/** 記錄鏈表中的節(jié)點的數(shù)量的原子類 */
private final AtomicInteger count = new AtomicInteger();
/**鏈表的頭節(jié)點
 */
transient Node<E> head;
/**
 * 鏈表的尾節(jié)點
 */
private transient Node<E> last;
/** 從鏈表隊列中獲取節(jié)點時防止多個線程同時操作所產(chǎn)生數(shù)據(jù)安全問題時所加的鎖 */
private final ReentrantLock takeLock = new ReentrantLock();
/** Wait queue for waiting takes */
private final Condition notEmpty = takeLock.newCondition();
/** 添加節(jié)點到鏈表隊列中防止多個線程同時操作所產(chǎn)生數(shù)據(jù)安全問題時所加的鎖 */
private final ReentrantLock putLock = new ReentrantLock();
/** Wait queue for waiting puts */
private final Condition notFull = putLock.newCondition();

/**
 * 創(chuàng)建默認容量大小的鏈表隊列
 */
public LinkedBlockingQueue() {
    this(Integer.MAX_VALUE);
}
/**
 * 創(chuàng)建指定容量大小的鏈表隊列
 */
public LinkedBlockingQueue(int capacity) {
    if (capacity <= 0) throw new IllegalArgumentException();
    this.capacity = capacity;
    //創(chuàng)建一個空節(jié)點,并將該節(jié)點設置為頭尾節(jié)點
    last = head = new Node<E>(null);
}
/**
 * 根據(jù)指定集合中的元素創(chuàng)建一個默認容量大小的鏈表隊列
 */
public LinkedBlockingQueue(Collection<? extends E> c) {
    //創(chuàng)建默認容量大小的鏈表隊列
    this(Integer.MAX_VALUE);
    //獲取添加元素節(jié)點的鎖
    final ReentrantLock putLock = this.putLock;
    //加鎖
    putLock.lock();
    try {
        //鏈表中節(jié)點的數(shù)量
        int n = 0;
        //遍歷集合中的元素
        for (E e : c) {
            if (e == null)
                throw new NullPointerException();
            if (n == capacity)
                throw new IllegalStateException("Queue full");
            //為元素創(chuàng)建一個節(jié)點,并將節(jié)點添加到鏈表的尾部,并設置節(jié)點為尾節(jié)點
            enqueue(new Node<E>(e));
            //鏈表中節(jié)點的數(shù)量自增
            ++n;
        }
        //記錄鏈表中節(jié)點的數(shù)量
        count.set(n);
    } finally {
        //釋放鎖
        putLock.unlock();
    }
}

public void put(E e) throws InterruptedException {
    if (e == null) throw new NullPointerException();
    int c = -1;
    //為指定元素創(chuàng)建節(jié)點
    Node<E> node = new Node<E>(e);
    //獲取添加元素節(jié)點的鎖
    final ReentrantLock putLock = this.putLock;
    //獲取記錄鏈表節(jié)點數(shù)量的原子類
    final AtomicInteger count = this.count;
    //加鎖,如果加鎖的線程被中斷了則拋出異常
    putLock.lockInterruptibly();
    try {
        //校驗鏈表中的節(jié)點數(shù)量是否到達了指定的容量
        //如果到達了指定的容量就進行阻塞等待
        //如果線程被喚醒了,但是鏈表中的節(jié)點數(shù)量還是未改變,則繼續(xù)阻塞等待
        //只有當頭節(jié)點出隊,新的節(jié)點才能繼續(xù)添加
        while (count.get() == capacity) {
            notFull.await();
        }
        //將新節(jié)點添加到鏈表的尾部并設置為尾節(jié)點
        enqueue(node);
        //獲取沒有添加當前節(jié)點時鏈表中的節(jié)點數(shù)量
        //并更新鏈表中的節(jié)點數(shù)量
        c = count.getAndIncrement();
        if (c + 1 < capacity)
            //喚醒等待添加節(jié)點的線程
            //可能當前線程在等待隊列中等待的時候
            //有新的線程要執(zhí)行添加節(jié)點的操作
            //但是鏈表的容量已經(jīng)到達最大,所以新的線程也會進行等待
            //當前線程被喚醒了并且鏈表的容量沒有到達最大則嘗試去喚醒等待的線程
            notFull.signal();
    } finally {
        //釋放鎖
        putLock.unlock();
    }
    if (c == 0)
        //c等于0說明添加當前節(jié)點的時候鏈表中沒有節(jié)點
        //可能有線程在獲取節(jié)點,但是鏈表中沒有節(jié)點
        //從而一直進行等待,當添加了節(jié)點的時候就需要喚醒獲取節(jié)點的線程
        signalNotEmpty();
}

public final void await() throws InterruptedException {
    if (Thread.interrupted())
        //線程被中斷拋出異常
        throw new InterruptedException();
    //為當前線程創(chuàng)建一個等待模式的節(jié)點并入隊,并將等待隊列中已經(jīng)取消等待的節(jié)點移除掉
    Node node = addConditionWaiter();
    //釋放當前線程的鎖,防止當前線程加了鎖,導致其它在等待的線程被喚醒之后不能獲取到鎖從而導致一直阻塞
    int savedState = fullyRelease(node);
    int interruptMode = 0;
    //如果指定節(jié)點還在等待隊列中等待則掛起
    //如果指定節(jié)點被中斷了則會將指定節(jié)點添加到同步等待隊列中
    //如果指定節(jié)點被喚醒了則會將指定節(jié)點添加到同步等待隊列中
    while (!isOnSyncQueue(node)) {
        //節(jié)點在等待隊列中則掛起
        LockSupport.park(this);
        //線程在等待隊列中被中斷則會添加到同步等待隊列中
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
            break;
    }
    //acquireQueued 指定節(jié)點中的線程被中斷了或者被喚醒了則會嘗試去獲取鎖
    //如果還未到指定節(jié)點中的線程獲取鎖的時候則會繼續(xù)掛起
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
        interruptMode = REINTERRUPT;
    if (node.nextWaiter != null)
        //指定節(jié)點的線程已經(jīng)獲取到了鎖并且節(jié)點關聯(lián)的下一個節(jié)點不為空
        //此時就需要將已經(jīng)獲取到鎖的節(jié)點從等待隊列中移除
        unlinkCancelledWaiters();
    if (interruptMode != 0)
        reportInterruptAfterWait(interruptMode);
}

final boolean isOnSyncQueue(Node node) {
    if (node.waitStatus == Node.CONDITION || node.prev == null)
        //指定節(jié)點還在等待隊列中此時就需要繼續(xù)等待
        return false;
    if (node.next != null)
        //指定節(jié)點已經(jīng)不在等待隊列中了
        return true;
    //從等待隊列中的尾節(jié)點開始向頭節(jié)點遍歷,校驗指定的節(jié)點是否在其中
    return findNodeFromTail(node);
}

public final void signal() {
    if (!isHeldExclusively())
        //加鎖的線程不是當前線程則拋出異常
        throw new IllegalMonitorStateException();
    //頭節(jié)點
    Node first = firstWaiter;
    if (first != null)
        //喚醒頭節(jié)點
        doSignal(first);
}
/**
 * 喚醒等待隊列中的頭節(jié)點
 * 如果等待隊列中的頭節(jié)點被取消等待或已經(jīng)被喚醒了
 * 此時就需要喚醒頭節(jié)點的后續(xù)的一個節(jié)點
 * 直到成功的喚醒一個節(jié)點中的線程
 */
private void doSignal(Node first) {
    do {
        if ( (firstWaiter = first.nextWaiter) == null)
            lastWaiter = null;
        first.nextWaiter = null;
    } while (!transferForSignal(first) && (first = firstWaiter) != null);
}
/**
* 將指定的節(jié)點添加到同步等待隊列中
* 并根據(jù)前一個節(jié)點的等待狀態(tài)來決定是否需要立刻喚醒指定節(jié)點
*/
final boolean transferForSignal(Node node) {
    if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
        //更改節(jié)點狀態(tài)失敗說明該節(jié)點已經(jīng)被喚醒了
        return false;
    //將要喚醒的節(jié)點添加到同步等待隊列中
    //并返回前一個節(jié)點
    Node p = enq(node);
    //前一個節(jié)點的等待狀態(tài)
    int ws = p.waitStatus;
    if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
        //如果前一個節(jié)點的等待狀態(tài)大于0則說明已經(jīng)被取消加鎖,此時就需要喚醒后續(xù)的節(jié)點,就是當前節(jié)點
        //前一個節(jié)點的等待狀態(tài)不大于0但是更改前一個節(jié)點的等待狀態(tài)時失敗則說明前一個節(jié)點已經(jīng)被喚醒了并更改了狀態(tài)
        //此時就需要嘗試將當前節(jié)點中的線程喚醒
        LockSupport.unpark(node.thread);
    return true;
}