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:21
Worker li si do work begin at 2017-07-09 10:33:21
Worker zhang san do work complete at 2017-07-09 10:33:26
Worker li si do work complete at 2017-07-09 10:33:29
all 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，若是则结束等待，反之则等待唤醒后结束等待。