根据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()方法而阻塞的节点。