CyclicBarrier、Semaphore、CountDownLatch、Condition工作流程源码分析

1.CyclicBarrier.wait()方法工作流程。

CyclicBarrier内部基于condition，维护一个count变量，每次调用一次wait(),内部调用了dowait(false, 0L)的方法，count就会减1，当count为0的时候，调用nextGeneration()方法，这个方法会调用trip.signalAll()唤醒所有线程,其中trip是CyclicBarrier内部维护的一个condition变量，并且把count重置为parties(初始值);如果count减1后不为0，就会调用wait方法加入等待队列。

/**
 * Main barrier code, covering the various policies.
 */
private int dowait(boolean timed, long nanos)
    throws InterruptedException, BrokenBarrierException,
           TimeoutException {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        final Generation g = generation;

        if (g.broken)
            throw new BrokenBarrierException();

        if (Thread.interrupted()) {
            breakBarrier();
            throw new InterruptedException();
        }

        int index = --count;
        if (index == 0) {  // tripped
            boolean ranAction = false;
            try {
                final Runnable command = barrierCommand;
                if (command != null)
                    command.run();
                ranAction = true;
                nextGeneration();
                return 0;
            } finally {
                if (!ranAction)
                    breakBarrier();
            }
        }

/**
 * Updates state on barrier trip and wakes up everyone.
 * Called only while holding lock.
 */
private void nextGeneration() {
    // signal completion of last generation
    trip.signalAll();//唤醒所有等待队列上的线程，加入到同步队列
    // set up next generation
    count = parties;
    generation = new Generation();
}

// loop until tripped, broken, interrupted, or timed out
        for (;;) {
            try {
                if (!timed)
                    trip.await(); //这里会调用wait方法加入等待队列
                else if (nanos > 0L)
                    nanos = trip.awaitNanos(nanos);
            } catch (InterruptedException ie) {
                if (g == generation && ! g.broken) {
                    breakBarrier();
                    throw ie;
                } else {
                    // We're about to finish waiting even if we had not
                    // been interrupted, so this interrupt is deemed to
                    // "belong" to subsequent execution.
                    Thread.currentThread().interrupt();
                }
            }

            if (g.broken)
                throw new BrokenBarrierException();

            if (g != generation)
                return index;

            if (timed && nanos <= 0L) {
                breakBarrier();
                throw new TimeoutException();
            }
        }
    } finally {
        lock.unlock();
    }

2.Semaphore.acquire()方法工作流程。

首先说明一下，Semaphore内部也是基于AQS，重写了AQS的tryReleaseShared(int releases)方法，Semaphore默认以非公平方式创建锁，acquire()方法会调用sync.acquireSharedInterruptibly(1)方法，以共享锁，可响应中断的方式获取许可。如果当前许可可用数不满足请求量，会调用doAcquireSharedInterruptibly方法，该方法会将当前请求线程通过addWaiter()的方法加入等待队列的队尾上，然后通过不断自旋的方式判断前继节点是不是head，是的话就继续通过tryAcquireShared(arg)方式获取许可，如果获取锁成功，则把当前线程的节点置为head节点，如果获取锁失败，则调用shouldParkAfterFailedAcquire方法判断前继节点是否为signal状态，是的话调用LockSupport.park(this);方法将当前线程挂起，等待被唤醒，不是的话继续往前寻找，找到安全点（即前继节点为signal状态的或者小于0，然后把前继节点状态改成signal，这样的话前继节点释放锁之后会唤醒他），然后会去判断当前线程的中断标志，如果为true，则调用cancelAcquire(node)方法，把当前节点的waitStatus状态置为CANCELLED，并且会把当前节点以及前继节点有cancelled状态的节点移除掉。在移除过程会找到最近的不为cancelled状态的前继节点，如果是head，则唤醒前继节点，否则就把前继节点状态改成signal。然后让前继节点的next节点指向当前node节点的next节点，最后当前node节点的next指向自己，发生GC的时候可以被回收掉。
这里说明一下，公平版本的tryAcquireShared(arg)方式获取许可，会先调用hasQueuedPredecessors()方法判断tail和head是否未初始化，是的话还是会把当前节点通过addWaiter()的方法加入同步队列的队尾，只不过会在addWaiter()的enq(final Node node)方法里面进行初始化tail = head，然后把当前node置为head的next节点。源代码如下：

   private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize  这里进行初始化，构造一个空节点为head
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;//这里吧head节点下一个节点指向当前node
                    return t;
                }
            }
        }
    }

3.semaphore.release()方法工作流程。

semaphore.release()方法会调用sync.releaseShared(1)方法，最终会调用tryReleaseShared方法，这个时候回判断释放许可后state变量是否会溢出，溢出抛出throw new Error(“Maximum permit count exceeded”);否则的话就通过CAS方式把state变量置为原来的state+releases的数量大小，返回true。返回true之后，就会调用doReleaseShared()方法，这时会把head节点的waitStatus置为0（失败就一直循环置为0），成功的话调用unparkSuccessor方法，这个方法会从唤醒他的下一个不为cancelled状态的节点（这里比较有意思，会从队尾开始寻找这个不为cancelled的节点，至于为什么不从他的next引用开始找，是因为队尾是随时变化的，有新的线程加入进来，而且有可能中间排队的线程会被中断取消掉）。

4.CountDownLatch.countDown()方法工作流程。

首先介绍一下，CountDownLatch内部也是基于AQS来进行同步，重写了tryAcquireShared(int acquires)和tryReleaseShared(int releases)方法，countDownLatch.countDown()会调用sync.releaseShared(1)方法。

  protected boolean tryReleaseShared(int releases) {
            // Decrement count; signal when transition to zero
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c-1;
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }

这里会把检查当前state是否为0，是的话返回false，啥都不做，否则state减1，返回判断state是否为0。

 public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) {
            doReleaseShared();
            return true;
        }
        return false;
    }

为0的话调用doReleaseShared()方法，看看他干了啥：

 for (;;) {
            Node h = head;
            if (h != null && h != tail) {
                int ws = h.waitStatus;
                if (ws == Node.SIGNAL) {
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                        continue;            // loop to recheck cases
                    unparkSuccessor(h);
                }
                else if (ws == 0 &&
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;                // loop on failed CAS
            }
            if (h == head)                   // loop if head changed
                break;
        }

如果当前head节点为signal状态则把当前node状态置为0，并唤醒head的下一个节点的线程，当当前状态为0的话则把head节点置为PROPAGATE传播唤醒状态。

5.CountDownLatch.await()方法工作流程。

会调用AQS的acquireSharedInterruptibly(int arg)方法，里面又会调用它自己实现的tryAcquireShared(arg)方法，这个方法会判断state是否等于0，是的话返回1，否则返回-1，不为0的时候，就会执行AQS的doAcquireSharedInterruptibly(int arg)方法，这个方法不多说了，前面semaphore分析过，会加入到同步队列的队尾并等待被唤醒。
总结：CountDownLatch就是await方法判断state是否为0，不为0则加入同步队列队尾等待被唤醒，当调用countdownLatch()方法则会把state减1，减到0的时候就唤醒同步队列的线程。

6.Condition的await()方法工作流程。

首先说明一下Condition是基于ReentrantLock的实现的，ReentrantLock又是基于AbstractQueuedSynchronizer的ConditionObject内部类实现的。其实就是基于AQS的等待队列实现的。Condition的await()方法其实就是调用了AQS内部类ConditionObject的await()方法，第一步就是判断是否被中断过，是的话抛出中断异常。否则就调用addConditionWaiter()方法把当前线程加入队尾，加入队尾之前会判断当前队尾的线程是否已经被取消，是的话就调用unlinkCancelledWaiters()方法，从firstWaiter节点开始往下遍历，找到状态不为CONDITION的节点，然后遍历清除掉，把为CONDITION节点的第一个置为firstWaiter。
上面加入队尾完成后开始调用fullyRelease(node)方法把所有state释放掉。里面会调用ReentrantLock的tryRelease方法，这个时候会判断当前线程是否为当前获取到ReentrantLock独占锁的线程，不是的话就会抛出IllegalMonitorStateException异常，所以说Condition是要配合ReentrantLock来使用的。不然调用await方法会抛出异常。如果释放成功，就会把当前独占锁设置为null，同时把同步队列的head节点线程唤醒去竞争锁，这样其他线程就可以竞争了；如果释放失败，就会把当前节点设置为CANCELLED并抛出IllegalMonitorStateException异常。释放成功后，就会调用LockSupport.park(this)方法把当前线程挂起。在挂起的过程中，如果之前被中断过，则抛出中断异常。
我们来总结一下Condition的await()都干了啥：
1.加入到等待队列的尾部；（会响应中断）
2.调用fullyRelease()方法释放获取的所有锁，把state变量置为0；
3.把当前ReentrantLock独占锁设置为null，同时唤醒同步队列的head的next节点的线程去竞争锁（这就是为什么condition适合做生产者消费者了，会唤醒其他condition的线程）；
4.调用LockSupport.park(this)把当前线程挂起。（会响应中断）。

7.Condition的signal()方法工作流程。

上面分析完await方法，我们来分析一下signal方法都干了啥吧。首先就是调用isHeldExclusively()方法判断当前线程是否获取了ReentrantLock的独占锁，没有的话就抛出IllegalMonitorStateException异常。他会获取当前等待队列的firstWaiter节点，不为null的话就 调用doSignal(first)方法。这个方法一上来就是判断当前等待队列是否只有它一个头结点，是的话就把lastWaiter 置为null，同时把他的下一个节点置为null，然后会执行transferForSignal方法，这里会判断头结点时候是否为CONDITION状态，不是的话就返回false，继续从头结点往下找到一个是CONDITION状态的节点并修改为0，否则调用enq(node)方法加入到同步队列队尾，这里需要注意就是enq方法会返回新添加队尾node的前继节点，然后判断这个前继节点是否被取消或者尝试把节点置为signal失败，就会直接把当前线程唤醒。
总结一下：
1.signal就是把当前等待队列的头结点拿出来transfer到同步队列。
2.如果transfer失败，说明这个节点之前已经被cancelled，继续在等待队列寻找下一个没有被cancelled的节点。
3.把这个节点transfer到同步队列，等待被唤醒。（这里请看第6节总结第3点，await()方法会唤醒同步队列的线程)。
doSignalAll()方法我这边就不讲了，自己去看吧，跟上面差不多，区别就是在transfer的时候会把等待队列的所有节点transfer到同步队列等待被唤醒去竞争锁。