CountDownLatch的实现原理

CountDownLatch是java并发包中辅助并发的工具类，目的是让并发运行的代码在某一个执行点阻塞，直到所有条件都满足，这里的条件就是调用countDown()方法，有点类似计数器的功能。

用法如

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(2);
        //如果没有countDown()操作，直接调用await方法则永远不会打印最后一行
        countDownLatch.countDown();
        countDownLatch.countDown();
        countDownLatch.await();
        System.out.println("运行结束");
    }

构造函数中传入的数字2，表示需要2次countDown()方法调用，否则代码会一直阻塞在await()方法调用处　　

比较常见的用法如，主线程声明一个CountDownLatch,然后多线程countDown，主线程在等待

     public static void testMultiThread() throws InterruptedException {
         int threadNum = 2;
         final CountDownLatch countDownLatch = new CountDownLatch(threadNum);
         ExecutorService executorService = Executors.newFixedThreadPool(threadNum);
         for(int i=0;i<threadNum;i++){
             executorService.execute(new Runnable() {
                 public void run() {
                     System.out.println("我的任务，打印出一句话");
                     countDownLatch.countDown();
                 }
             });
         }
         countDownLatch.await();
         System.out.println("全部任务都结束了，欧耶");
         executorService.shutdown();
     }

运行结果

我的任务，打印出一句话
我的任务，打印出一句话
全部任务都结束了，欧耶

Process finished with exit code 0

如果把第三行代码修改成

 final CountDownLatch countDownLatch = new CountDownLatch(threadNum+1);

　　

那么程序将永远无法打印出

全部任务都结束了，欧耶

以上是这个类的表象行为，那么它是如何在多线程做到这样的功能呢

先来看看它的类结构

CountDownLacth中，有6个public的方法，一个内部私有类Sync，及一个Sync实例的变量sync

Sync是这个类的关键，它保证了countDown(),await()方法在多线程场景下可以保证countDownLatch的可见性（正常的同步）

我们先来自己实现一个CountDownLacth类，使用synchronized关键字实现

MyCountDownLatch模拟了countDown和await方法，通过synchronized和私有变量state来达到这个目的。synchronized的劣势在于锁机制完全互斥，并发量高时性能下降比较明显，无法维持常态化的性能（JDK 5）。因此CountDownLatch以及并发包中的类都采用了取巧的方式，通过线程自旋来追求线程响应时间，而不是让线程只能一直等待锁被释放再竞争。1.6之后，synchronized的性能和ReentrantLock的性能其实已经相当，偏向锁也改进了一个线程重复获取锁时不需要cpu切换上下文。

private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;

　　　　 //初始化总的countdown次数值，这个操作涉及内存语义 volatile写
        Sync(int count) {
            setState(count);
        }

        int getCount() {
            return getState();
        }

　　　　 //尝试获取共享锁，如果可以获取锁，需要返回对应的状态值，这个方法总是由执行获取的线程调用
        protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -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;
            }
        }
    }

　　

CountDownLatchd countDown方法会调用

Sync的tryReleaseShared去将计数器-1

public void countDown() {
        sync.releaseShared(1);
    }

　

AbstractQueuedSynchronizer类方法

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

　

public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

AbstractQueuedSynchronizer类方法
public final void acquireSharedInterruptibly(int arg)
        throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    if (tryAcquireShared(arg) < 0)
        doAcquireSharedInterruptibly(arg);
}

AbstractQueuedSynchronizer类方法
/**
 * Acquires in shared interruptible mode.
 * @param arg the acquire argument
 */
private void doAcquireSharedInterruptibly(int arg)
    throws InterruptedException {
    final Node node = addWaiter(Node.SHARED);
    boolean failed = true;
    try {
        for (;;) {
            final Node p = node.predecessor();
            if (p == head) {
                int r = tryAcquireShared(arg);
                if (r >= 0) {
                    setHeadAndPropagate(node, r);
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

　　

　

　

await()方法Sync的tryAcquireShared方法不断判断计数器值为0,方法返回正数，await方法直接返回，亦即是获取了锁

 

　　

AbstractQueuedSynchronizer类是concurrent包的一个基础类，基于它，我们可以实现并发安全的诸多功能，例如CountDownLacth

    /**
     * The synchronization state.
     */
    private volatile int state;

　　

AbstractQueuedSynchronizer类有一个volatile的变量，CountDownLacth中的Sync类，getState()方法其实就是获取它的值
由于volatile关键字的特殊内存语义，当它被修改时，将本地高速缓存中的值写到主存中去，当它的值被读取时，会把本地缓存中state置为无效，到主存获取值，因此每个线程都能获取到他最新的值

   countDownLatch.countDown();
   -> sync.releaseShared(1);
   -> 

    public final boolean releaseShared(int arg) {
	//countdown时，尝试判断当前状态，如果状态已经可以完全释放锁时，进行释放锁操作
        if (tryReleaseShared(arg)) {
            doReleaseShared(); //释放共享锁
            return true;
        }
        return false;
    }

	/**
     * Release action for shared mode -- signals successor and ensures
     * propagation. (Note: For exclusive mode, release just amounts
     * to calling unparkSuccessor of head if it needs signal.)
     */
    private void doReleaseShared() {
        /* 判断是否已经有线程(node)在等待，如果在等待，则从head开始，寻找后继节点，并唤醒他们
		 * 直到最后head 为null或head == tail,才退出，退出时，已然唤醒了所有需要唤醒的线程
         * Ensure that a release propagates, even if there are other
         * in-progress acquires/releases.  This proceeds in the usual
         * way of trying to unparkSuccessor of head if it needs
         * signal. But if it does not, status is set to PROPAGATE to
         * ensure that upon release, propagation continues.
         * Additionally, we must loop in case a new node is added
         * while we are doing this. Also, unlike other uses of
         * unparkSuccessor, we need to know if CAS to reset status
         * fails, if so rechecking.
         */
        for (;;) {
            Node h = head;  //等待获取锁的队列
            if (h != null && h != tail) {    //head == tail 时，是一个特殊情况，是第一个node入队时的临时状态,此时head节点上没有等待的线程
                int ws = h.waitStatus;
                if (ws == Node.SIGNAL) {
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                        continue;            // loop to recheck cases
                    unparkSuccessor(h);  //head唤醒后继线程
                }
                else if (ws == 0 &&
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))  //尝试设置waitStatus状态为PROPAGATE
                    continue;                // loop on failed CAS
            }
            if (h == head)                   // loop if head changed
                break;
        }
    }

　　

	countDownLatch.await();
	->  sync.acquireSharedInterruptibly(1);
	->
	/**
     * Acquires in shared mode, aborting if interrupted.  Implemented
     * by first checking interrupt status, then invoking at least once
     * {@link #tryAcquireShared}, returning on success.  Otherwise the
     * thread is queued, possibly repeatedly blocking and unblocking,
     * invoking {@link #tryAcquireShared} until success or the thread
     * is interrupted.
     * @param arg the acquire argument.
     * This value is conveyed to {@link #tryAcquireShared} but is
     * otherwise uninterpreted and can represent anything
     * you like.
     * @throws InterruptedException if the current thread is interrupted
     */
    public final void acquireSharedInterruptibly(int arg)
            throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        if (tryAcquireShared(arg) < 0)  //尝试判断共享锁状态，即判断state是否为0了，如果已经为0，表示期待的状态已经达到了，锁的状态已经标识不需等待了，直接返回
            doAcquireSharedInterruptibly(arg); //为0后
    }

	/**
     * Acquires in shared interruptible mode.
     * @param arg the acquire argument
     */
    private void doAcquireSharedInterruptibly(int arg)
        throws InterruptedException {
        final Node node = addWaiter(Node.SHARED); //当前线程装入node，此时等待队列不为空了
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();  //当前线程的前继线程
                if (p == head) { //前继为head
                    int r = tryAcquireShared(arg); //判断state状态，是否已经ok
                    if (r >= 0) {  //state值为0时，r == 1
                        setHeadAndPropagate(node, r); //当前node设置为head,尝试获取下一个node
                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())  //尝试park(阻塞)当前线程，有点像进入wait状态，处理器可能不会分配时间
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

　这里需要说明一下，node的waitStatus是在何时被设置为Node.SIGNAL状态的

shouldParkAfterFailedAcquire方法中，pred参数为当前node的前继node，方法一进来就判断了pred.waitStatus是否为Node.SIGNAL，如果已经是这个状态了就直接返回
ws>0表示CANCELLED状态，因为其他状态都是<=0的，此时遍历的将这种无效的node去掉；如果ws <= 0,就将pred的状态变成Node.SIGNAL，并返回false;这里可以看到，如果前缀node已经是SIGNAL状态
就会park当前节点线程，如果，前缀node是未cancel状态，就设置为SIGNAL状态。这样，在调用await时，如果无法立即返回，就会将当前线程阻塞，并设置前置node状态为SIGNAL。这也对应了releaseShared
中的Node.SIGAL状态的判断。await()是从tail -> head方向做的；countdown(releaseShared)的方向是从head -> tail的，这样，等待锁的线程不断判断前缀node，释放锁的线程不断更新head -> tail
状态,随着head -> tail状态更新完毕，await等待锁也等到了p == head，返回true

  /**
     * Checks and updates status for a node that failed to acquire.
     * Returns true if thread should block. This is the main signal
     * control in all acquire loops.  Requires that pred == node.prev.
     *
     * @param pred node's predecessor holding status
     * @param node the node
     * @return {@code true} if thread should block
     */
    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park.
             */
            return true;
        if (ws > 0) {
            /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             */
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            /*
             * waitStatus must be 0 or PROPAGATE.  Indicate that we
             * need a signal, but don't park yet.  Caller will need to
             * retry to make sure it cannot acquire before parking.
             */
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

　　

Java的LockSupport.park()实现分析 参见博客：　https://blog.csdn.net/hengyunabc/article/details/28126139

附waitStatus的各种状态

	/**
         * Status field, taking on only the values:
         *   SIGNAL:     The successor of this node is (or will soon be)
         *               blocked (via park), so the current node must
         *               unpark its successor when it releases or
         *               cancels. To avoid races, acquire methods must
         *               first indicate they need a signal,
         *               then retry the atomic acquire, and then,
         *               on failure, block. 线程的后继线程正/已被阻塞，当该线程release或cancel时，要唤醒这个后继线程(unpark)
         *   CANCELLED:  This node is cancelled due to timeout or interrupt.
         *               Nodes never leave this state. In particular,
         *               a thread with cancelled node never again blocks. 由于timeout或线程被中断时的状态
         *   CONDITION:  This node is currently on a condition queue.
         *               It will not be used as a sync queue node
         *               until transferred, at which time the status
         *               will be set to 0. (Use of this value here has
         *               nothing to do with the other uses of the
         *               field, but simplifies mechanics.) 表明该线程被处于条件队列，就是因为调用了Condition.await而被阻塞
         *   PROPAGATE:  A releaseShared should be propagated to other
         *               nodes. This is set (for head node only) in
         *               doReleaseShared to ensure propagation
         *               continues, even if other operations have
         *               since intervened.   传播共享锁，只能在head上设置这个状态
         *   0:          None of the above
         *
         * The values are arranged numerically to simplify use.
         * Non-negative values mean that a node doesn't need to
         * signal. So, most code doesn't need to check for particular
         * values, just for sign.
         *
         * The field is initialized to 0 for normal sync nodes, and
         * CONDITION for condition nodes.  It is modified using CAS
         * (or when possible, unconditional volatile writes).
         */
        volatile int waitStatus;