根据AQS推测CountDownLatch及源码分析

    CountDownLatch实现的是AQS中的共享模式。一般用于线程间的协作，如主线程创建了多个线程去做别的工作，等到这些线程都执行完毕了才能往下执行，这时候就可以用countDownLatch来实现。

public class CountDownLatch2 {    public static void main(String[] args) throws InterruptedException {        final CountDownLatch latch =new CountDownLatch(5);        final AtomicInteger in=new AtomicInteger(1);        for(int i=0;i<5;i++){            Thread t=new Thread(new Runnable() {                @Override                public void run() {                    System.out.println("线程"+in.getAndIncrement()+"做完了准备工作");                    latch.countDown();                }            });            t.start();        }        System.out.println("等待其他线程都执行完毕准备工作");        latch.await();        System.out.println("所有准备工作已经完毕，可以往下执行");    }}输出：线程1做完了准备工作线程3做完了准备工作等待其他线程都执行完毕准备工作线程4做完了准备工作线程2做完了准备工作线程5做完了准备工作所有准备工作已经完毕，可以往下执行

    可以看到,latch.await()会阻塞到所有线程都调用了latch.countdown()之后才能往下执行。
    我们就来研究一下CountDownLatch是怎么实现的呢？

    先放出根据http://blog.csdn.net/FoolishAndStupid/article/details/75676027 中得到的简单的结论：

    我们又知道，countdownlatch.await()会阻塞当前线程直到所有线程都调用了countdown()之后。根据图1可以推论出await()方法调用的是acquireShared()方法，然后latch自定义的tryAcquireShared()方法,当stata!=0的时候，会返回<0,这样，await()方法就会阻塞。

    那么当所有线程都调用了countdown()之后，阻塞的线程又会唤醒。我们可以继续推论出countdown()方法其实是调用的tryReleaseShared()方法。当state=0时,tryReleaseShared()返回true，就可以成功唤醒阻塞的线程了。
    那我们来看一下到底是不是呢？
    先看看await()方法:

     countdown.await()

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

    再往下看：

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

    可以看到，其实就是调用自定义同步器中实现的tryAcquireShared()方法，如果返回值<0，则将线程阻塞。
    那再来看看自定义同步器中的tryAcquireShared()：

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

    果然，跟我们前面的推测一样，当state!=0的时候就返回-1，从而通过AQS来阻塞线程。

countdown.release()方法：

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

    releaseShared是AQS中已经实现的方法，进来看看：

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

    可以看到，它也是调用的自定义同步器实现的tryReleaseShared()方法：

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

    跟我们前面推测的一样，当state=0的时候，就会返回true,从而唤醒后继节点，也就是调用await()方法的线程。

    所以总结起来就是，countDownLatch中自定义同步器实现了AQS的共享模式，实现了tryAcquireShared()方法和tryReleaseShared()方法。其中tryAcquireShared()方法被await()方法调用，在state!=0的时候返回-1（表示资源获取失败），从而实现阻塞调用线程的目的。
    而tryReleaseShared()方法则是被countdown()方法调用，在state=0的时候返回true，从而唤醒调用await()方法而阻塞的节点。