多线程并发编程19-线程同步之CountDownLatch

    说到线程同步第一个想到的一定是Thread类的join方法，当需要等待一个线程执行结束之后再接着执行本线程接下去的逻辑，join经常会在这种场景下被使用，但是join方法是Thread类的方法，需要使用Thread类实例进行调用，不够灵活，不能满足不同场景的需求，例如使用线程池来管理线程的时，一般直接添加Runnable到线程池，这个时候就没办法再调用线程的join方法，而接下来要介绍的CountDownLatch就可以满足该需求。

    CountDownLatch是一个递减计数器，当计数器的值递减为0时，调用CountDownLatch类的await方法的线程会被唤醒，从而接着执行该线程的后续逻辑，CountDownLatch的计数器是一次性的，也就是等到计数器值变为0后，再调用CountDownLatch的await和countdown方法会立刻返回。下面通过一个简单的需求来介绍下CountDownLatch的使用。

    使用线程池执行10个任务，当所有任务执行完之后，主线程打印出“任务完成！”。

final int taskCount = 10;

//（1）初始化一个计数值为10的CountDownLatch。

CountDownLatch countDownLatch = new CountDownLatch(taskCount);

ExecutorService executorService = Executors.newFixedThreadPool(5);

System.out.println("开始执行任务");

for (int i = 0; i < taskCount; i++) {

//（2）每个任务执行完之后都将CountDownLatch的值减1，注意：在finally中进行减操作

    executorService.submit(new Runnable() {

        @Override

        public void run() {

            try {

                Thread.sleep(1000);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }finally {

                countDownLatch.countDown();

            }

        }

    });

}

System.out.println("等待任务执行");

try {

//（3）调用CountDownLatch的await方法进行阻塞，等待计数器的值为0后被唤醒。

    countDownLatch.await();

} catch (InterruptedException e) {

    e.printStackTrace();

}

System.out.println("任务完成！！");

    上面的例子展示了CountDownLatch实现线程间同步，那么CountDownLatch是如何实现线程间同步？CountDownLatch是如何进行计数器值递减？CountDownLatch的计数器值是如何初始化的？CountDownLatch在使用中会有哪些问题？带着这些疑问去CountDownLatch内部进行一探究竟。

    CountDownLatch内部使用AQS实现，关于AQS读者可以翻看前面的文章。将初始化的计数值传递给AQS中的state，并通过共享的方式进行state的获取和释放。

CountDownLatch构造函数

    CountDownLatch构造函数创建内部类Sync继承自AQS，将初始化的计数器值赋值给AQS中的state。

public CountDownLatch(int count) {    

    if (count < 0) throw new IllegalArgumentException("count < 0");

    this.sync = new Sync(count);

}

private static final class Syncextends AbstractQueuedSynchronizer

Sync(int count) {

    setState(count);

}

public void await()

    阻塞挂起调用线程，直到计数器减到0。调用线程可被中断返回。

public void await() throws InterruptedException {

//（1）调用AQS中共享方式获取锁方法。

    sync.acquireSharedInterruptibly(1);

}

//AQS中共享方式获取锁。

public final void acquireSharedInterruptibly(int arg)

        throws InterruptedException {

//（1）对中断响应。被中断则抛出异常。

    if (Thread.interrupted())

        throw new InterruptedException();

//（2）尝试获取共享锁，如果返回值小于0则将当前线程放到AQS的阻塞队列中并阻塞当前线程。

    if (tryAcquireShared(arg) < 0)

        doAcquireSharedInterruptibly(arg);

}

//CountDownLatch内部类Sync类实现的AQS接口。
protected int tryAcquireShared(int acquires) {

//（1）判断计数器值是否为0，也就是判断AQS中的state是否为0。

    return (getState() == 0) ? 1 : -1;

}

public void countDown()

    递减计数器，当减到0的时候，唤醒所有调用CountDownLatch.await()方法而阻塞的线程。如果计数器的值为0则不做任何处理。

public void countDown() {

    sync.releaseShared(1);

}

public final boolean releaseShared(int arg) {

//（1）如果计数器值减到0返回true，则将所有因为调用CountDownLatch.await()方法而阻塞的线程唤醒。

    if (tryReleaseShared(arg)) {

        doReleaseShared();

        return true;

    }

    return false;

}

//CountDownLatch内部类Sync类实现的AQS接口。
protected boolean tryReleaseShared(int releases) {

    // （1）使用CAS+自旋的方式将计数器值减1，也就是将AQS中的state值减1，如果计数器值为0则直接返回false

    for (;;) {

        int c = getState();

        if (c == 0)

            return false;

        int nextc = c-1;

        if (compareAndSetState(c, nextc))

            return nextc == 0;

    }

}

    CountDownLatch的原理就是通过内部类Sync实现AQS的tryAcquireShared和tryReleaseShared方法，以共享锁的原理来实现计时器的递减，从而实现线程间的同步。

    今天的分享就到这，有看不明白的地方一定是我写的不够清楚，所有欢迎提任何问题以及改善方法。