java 并发工具包 -倒计数CountDownLatch

简介

CountDownLatch 是一个同步器，翻译过来就是倒计数，意思就是用倒数来计数，当为0的时候结束。

源码分析

public class CountDownLatch {    /**     * 同步器，继承于aqs用来计数     */    private static final class Sync extends AbstractQueuedSynchronizer {        private static final long serialVersionUID = 4982264981922014374L;        //初始化设置状态，即设置初始化计数器        Sync(int count) {            setState(count);        }        //获取state 即获取当前的计数器        int getCount() {            return getState();        }//重写父类方法，尝试判断当前值是否为0          protected int tryAcquireShared(int acquires) {            return (getState() == 0) ? 1 : -1;        }    //重写父类方 尝试判断是否-1是否为0        protected boolean tryReleaseShared(int releases) {            for (;;) {                int c = getState();                if (c == 0)                    return false;                int nextc = c-1;                //cas 替换state值，如果当前不匹配则循环直至state为0或者匹配成功                if (compareAndSetState(c, nextc))                    return nextc == 0;            }        }    }    private final Sync sync;   //初始化  其实就是去初始化sync    public CountDownLatch(int count) {        if (count < 0) throw new IllegalArgumentException("count < 0");        this.sync = new Sync(count);    }    public void await() throws InterruptedException {    //如果计数器还大于0则阻塞当前线程  直到计数器=0为止        sync.acquireSharedInterruptibly(1);    }    //要么一直阻塞到时间过期，要么计数器=0    public boolean await(long timeout, TimeUnit unit)        throws InterruptedException {        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));    }      //计数器-1  如果-1后=0 则释放线程    public void countDown() {        sync.releaseShared(1);    }        //获取当前计数器    public long getCount() {        return sync.getCount();    }    public String toString() {        return super.toString() + "[Count = " + sync.getCount() + "]";    }}

CountDownLatch源码之所以简单得易于AbstractQueuedSynchronizer 同步器，基本上所有的操作都是由AbstractQueuedSynchronizer 处理

简单例子

public class CountDownLatchTest {    public static void main(String[] args) throws InterruptedException {        CountDownLatch countDownLatch = new CountDownLatch(2);        new Thread(new Runnable() {            @Override            public void run() {                try {                    countDownLatch.await();                    System.out.println("释放线程1");                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        }).start();        new Thread(new Runnable() {            @Override            public void run() {                try {                    countDownLatch.await();                    System.out.println("释放线程2");                } catch (InterruptedException e) {                    // TODO Auto-generated catch block                    e.printStackTrace();                }            }        }).start();        new Thread(new Runnable() {            @Override            public void run() {                System.out.println("计数器-1");                countDownLatch.countDown();            }        }).start();        new Thread(new Runnable() {            @Override            public void run() {                System.out.println("计数器-1");                countDownLatch.countDown();            }        }).start();    }}

总结：

我们前面讲到CyclicBarrier同步器，两者功能类似，都是倒计数，当为0时，释放阻塞线程，但是CyclicBarrier针对的是主线程或者说一个线程，CountDownLatch针对的一组线程（上面例子中有两个线程）；
CyclicBarrier可以接收Runnable参数，CountDownLatch不能；
CyclicBarrier通过执行await-1并且一直阻塞直到0大家一起接着执行，CountDownLatch通过countDown，不会阻塞；
这么说吧
CyclicBarrier ：主线程和子线程最后会同时执行（如果await后面没有业务处理，和 CountDownLatch效果也类似）
CountDownLatch：一般子线程不管主线程，自己先执行掉