CountDownLatch源码分析

1、使用示例

CountDownLatch用于实现多个线程同步，一个典型场景是：等待线程B等待N个工作线程A1、A2、...、An并发完成后，才继续往下执行。一个N=2时的示例代码如下（代码转自http://www.iteye.com/topic/1002652）：

package com.wenc.concurrency;import java.text.SimpleDateFormat;import java.util.Date;import java.util.concurrent.CountDownLatch;public class CountDownLatchDemo {final static SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");      public static void main(String[] args) throws InterruptedException {          CountDownLatch latch=new CountDownLatch(2);//两个工人的协作          Worker worker1=new Worker("zhang san", 5000, latch);          Worker worker2=new Worker("li si", 8000, latch);          worker1.start();//          worker2.start();//          latch.await();//等待所有工人完成工作          System.out.println("all work done at "+sdf.format(new Date()));      }                  static class Worker extends Thread{          String workerName;           int workTime;          CountDownLatch latch;          public Worker(String workerName ,int workTime ,CountDownLatch latch){               this.workerName=workerName;               this.workTime=workTime;               this.latch=latch;          }          public void run(){              System.out.println("Worker "+workerName+" do work begin at "+sdf.format(new Date()));              try {doWork();//工作了 } catch (InterruptedException e) {e.printStackTrace();}finally{            System.out.println("Worker "+workerName+" do work complete at "+sdf.format(new Date()));              latch.countDown();//工人完成工作，计数器减一  }        }                    private void doWork() throws InterruptedException{          Thread.sleep(workTime);            }      }  }

输出：

Worker zhang san do work begin at 2017-07-09 10:33:21Worker li si do work begin at 2017-07-09 10:33:21Worker zhang san do work complete at 2017-07-09 10:33:26Worker li si do work complete at 2017-07-09 10:33:29all work done at 2017-07-09 10:33:29

2、源码分析

涉及CountDownLatch的主要代码：

        CountDownLatch latch=new CountDownLatch(2);//两个工人的协作 

latch.countDown();//工人完成工作，计数器减一 

        latch.await();//等待所有工人完成工作  

2.1、new CountDownLatch()

调用构造函数

    public CountDownLatch(int count) {        if (count < 0) throw new IllegalArgumentException("count < 0");        this.sync = new Sync(count);    }

参数count必须大于零，然后实例化一个内部类Sync并赋值给CountDownLatch成员变量sync。内部类Sync是实现线程同步的关键，它通过自定义实现线程同步器AbstractQueuedSynchronizer来完成同步功能。AbstractQueuedSynchronizer是功能java concurrency里实现同步功能的基础类，对于java并发实现非常重要（可参考http://ifeve.com/introduce-abstractqueuedsynchronizer/），然而不幸的是CountDownLatch并未使用它的高深功能，仅仅通过compareAndSetInt操作AbstractQueuedSynchronizer一个volatile成员变量state就达到了目的。

事实上，new CountDownLatch(2)只是单纯地将通过内部类Sync把AbstractQueuedSynchronizer实例的state变量赋值为2。相关代码如下

CountDownLatch:

    /**     * Synchronization control For CountDownLatch.     * Uses AQS state to represent count.     */    private static final class Sync extends AbstractQueuedSynchronizer {        private static final long serialVersionUID = 4982264981922014374L;        Sync(int count) {            setState(count);        }        int getCount() {            return getState();        }        public int tryAcquireShared(int acquires) {            return getState() == 0? 1 : -1;        }        public 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;            }        }    }    private final Sync sync;

加粗部分setState函数是AbstractQueuedSynchronizer提供的API：

    /**     * The synchronization state.     */    private volatile int state;    /**     * Returns the current value of synchronization state.     * This operation has memory semantics of a <tt>volatile</tt> read.     * @return current state value     */    protected final int getState() {        return state;    }    /**     * Sets the value of synchronization state.     * This operation has memory semantics of a <tt>volatile</tt> write.     * @param newState the new state value     */    protected final void setState(int newState) {        state = newState;    }

2.2、CountDownLatch.countDown()

CountDownLatch:

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

AbstractQueueSynchronizer：

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

CountDownLatch.Sync:

        public 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;            }        }

可见，AbstractQueueSynchronizer定义了final方法releaseShared，提供一个同步流程且不允许子类修改；CountDownLatch内部类Sync的tryReleaseShared方法实现自定义逻辑，它并不关心输入参数release（为更复杂的同步器准备），仅仅在for循环内部利用CAS原子操作（详见我的另一篇：点击打开链接）如果state已为0，则直接返回；反之，尝试将当前state减1，直到成功为止。

至于AbstractQueueSynchronizer的doReleaseShared()方法，

    private void 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;        }    }

由于CountDownLatch只涉及AbstractQueueSynchronizer的成员变量state，对其sync队列、Condition队列毫无兴趣（head==null,tail==null），

因此doReleaseShared快速地从h==head处break了出来，事实上什么都没做。

2.3、CountDownLatch.await()

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

调用AbstractQueueSynchronizer的方法：

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

如果当前线程中断状态为真，则响应中断而抛出中断异常。反之则执行CountDownLatch内部类Sync自定义的tryAcquireShare()方法：

        public int tryAcquireShared(int acquires) {            return getState() == 0? 1 : -1;        }

然，它仅仅是判断当前state值是否已减为0，如果为0则什么也不做，await返回，等待线程就可以认为工作线程都执行完毕，可以继续执行后面的逻辑了；

如果state还没有到达0，则执行doAcquireSharedInterruptibly()方法：

    private void doAcquireSharedInterruptibly(int arg)        throws InterruptedException {        final Node node = addWaiter(Node.SHARED);        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                        return;                    }                }                if (shouldParkAfterFailedAcquire(p, node) &&                    parkAndCheckInterrupt())                    break;            }        } catch (RuntimeException ex) {            cancelAcquire(node);            throw ex;        }        // Arrive here only if interrupted        cancelAcquire(node);        throw new InterruptedException();    }

这里比较复杂，简而言之，就是把当前等待线程加入AQS的虚拟队列中，并在parkCheckInterrupt()方法中调用LockSupport.park方法阻塞等待线程，

直到工作线程工作完毕后唤醒等待线程。之后等待线程才得以继续执行。

3、结论

CountDownLatch利用AQS同步器，操作AQS的volatile变量state来完成同步操作，其中new CountDownLatch(int n)只将state初始化为n，countDown操作将state减1，

await()方法判断state是否为0，若是则结束等待，反之则等待唤醒后结束等待。