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

/**
 * 創(chuàng)建默認(rèn)容量大小的鏈表隊(duì)列
 */
public LinkedBlockingQueue() {
    this(Integer.MAX_VALUE);
}
/**
 * 創(chuàng)建指定容量大小的鏈表隊(duì)列
 */
public LinkedBlockingQueue(int capacity) {
    if (capacity <= 0) throw new IllegalArgumentException();
    this.capacity = capacity;
    //創(chuàng)建一個(gè)空節(jié)點(diǎn),并將該節(jié)點(diǎn)設(shè)置為頭尾節(jié)點(diǎn)
    last = head = new Node<E>(null);
}
/**
 * 根據(jù)指定集合中的元素創(chuàng)建一個(gè)默認(rèn)容量大小的鏈表隊(duì)列
 */
public LinkedBlockingQueue(Collection<? extends E> c) {
    //創(chuàng)建默認(rèn)容量大小的鏈表隊(duì)列
    this(Integer.MAX_VALUE);
    //獲取添加元素節(jié)點(diǎn)的鎖
    final ReentrantLock putLock = this.putLock;
    //加鎖
    putLock.lock();
    try {
        //鏈表中節(jié)點(diǎn)的數(shù)量
        int n = 0;
        //遍歷集合中的元素
        for (E e : c) {
            if (e == null)
                throw new NullPointerException();
            if (n == capacity)
                throw new IllegalStateException("Queue full");
            //為元素創(chuàng)建一個(gè)節(jié)點(diǎn),并將節(jié)點(diǎn)添加到鏈表的尾部,并設(shè)置節(jié)點(diǎn)為尾節(jié)點(diǎn)
            enqueue(new Node<E>(e));
            //鏈表中節(jié)點(diǎn)的數(shù)量自增
            ++n;
        }
        //記錄鏈表中節(jié)點(diǎn)的數(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é)點(diǎn)
    Node<E> node = new Node<E>(e);
    //獲取添加元素節(jié)點(diǎn)的鎖
    final ReentrantLock putLock = this.putLock;
    //獲取記錄鏈表節(jié)點(diǎn)數(shù)量的原子類
    final AtomicInteger count = this.count;
    //加鎖,如果加鎖的線程被中斷了則拋出異常
    putLock.lockInterruptibly();
    try {
        //校驗(yàn)鏈表中的節(jié)點(diǎn)數(shù)量是否到達(dá)了指定的容量
        //如果到達(dá)了指定的容量就進(jìn)行阻塞等待
        //如果線程被喚醒了,但是鏈表中的節(jié)點(diǎn)數(shù)量還是未改變,則繼續(xù)阻塞等待
        //只有當(dāng)頭節(jié)點(diǎn)出隊(duì),新的節(jié)點(diǎn)才能繼續(xù)添加
        while (count.get() == capacity) {
            notFull.await();
        }
        //將新節(jié)點(diǎn)添加到鏈表的尾部并設(shè)置為尾節(jié)點(diǎn)
        enqueue(node);
        //獲取沒有添加當(dāng)前節(jié)點(diǎn)時(shí)鏈表中的節(jié)點(diǎn)數(shù)量
        //并更新鏈表中的節(jié)點(diǎn)數(shù)量
        c = count.getAndIncrement();
        if (c + 1 < capacity)
            //喚醒等待添加節(jié)點(diǎn)的線程
            //可能當(dāng)前線程在等待隊(duì)列中等待的時(shí)候
            //有新的線程要執(zhí)行添加節(jié)點(diǎn)的操作
            //但是鏈表的容量已經(jīng)到達(dá)最大,所以新的線程也會(huì)進(jìn)行等待
            //當(dāng)前線程被喚醒了并且鏈表的容量沒有到達(dá)最大則嘗試去喚醒等待的線程
            notFull.signal();
    } finally {
        //釋放鎖
        putLock.unlock();
    }
    if (c == 0)
        //c等于0說明添加當(dāng)前節(jié)點(diǎn)的時(shí)候鏈表中沒有節(jié)點(diǎn)
        //可能有線程在獲取節(jié)點(diǎn),但是鏈表中沒有節(jié)點(diǎn)
        //從而一直進(jìn)行等待,當(dāng)添加了節(jié)點(diǎn)的時(shí)候就需要喚醒獲取節(jié)點(diǎn)的線程
        signalNotEmpty();
}

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

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

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