同步工具之CountDownLatch闭锁

CountDownLatch是一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待 ，即CountDownLatch允许一个或多个线程等待其他线程完成操作。闭锁可以延迟线程的进度直到其到达终止状态，闭锁可以用来确保某些活动直到其他活动都完成才继续执行。

CountDownLatch简介

在多线程协作完成业务功能时，有时候需要等待其他多个线程完成任务之后，主线程才能继续往下执行业务功能，在这种的业务场景下，通常可以使用Thread类的join方法，让主线程等待被join的线程执行完之后，主线程才能继续往下执行。当然，使用线程间消息通信机制也可以完成。其实，Java并发工具类中为我们提供了类似“倒计时”这样的工具类，可以十分方便的完成所说的这种业务场景。

CountDownLatch类似计数器的功能，CountDownLatch是一种灵活的闭锁实现，能够使一个线程在等待另外一些线程完成各自工作之后，再继续执行。使用一个计数器进行实现。计数器初始值为线程的数量。当每一个线程完成自己任务后，计数器的值就会减一。当计数器的值为0时，表示所有的线程都已经完成了任务，然后在CountDownLatch上等待的线程就可以恢复执行任务。

CountDownLatch方法

JDK1.8中CountDownLatch方法如下.

先从CountDownLatch的构造方法看起：

public CountDownLatch(int count)

构造方法会传入一个整型数N，之后调用CountDownLatch的countDown方法会对N减一，直到N减到0的时候，当前调用await方法的线程才继续执行。

CountDownLatch的方法不是很多，将它们一个个列举出来：

1. await() throws InterruptedException：调用该方法的线程等到构造方法传入的N减到0的时候，才能继续往下执行；
2. await(long timeout, TimeUnit unit)：与上面的await方法功能一致，只不过这里有了时间限制，调用该方法的线程等到指定的timeout时间后，不管N是否减至为0，都会继续往下执行；
3. countDown()：使CountDownLatch初始值N减1；
4. long getCount()：获取当前CountDownLatch维护的值；

CountDownLatch图示

CountDownLatch图示

CountDownLatch实例

面试题：实现一个容器，提供两个方法，一个size读,一个add写两个线程，线程1往自定义容器中添加十个元素，线程2实时监控容器中的数量，在容器中元素个数为5的时候输出并结束线程使用门闩，门闩初始为1，当变为0的时候门闩打开，线程2就受到了通知，输出并结束。

代码实现

package wideth.util;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

public class MyCountDownLatch {

    private volatile List<Object> list = new ArrayList<>();

    private void add(Object o) {
        list.add(o);
    }

    private int size() {
        return list.size();
    }

    public static void main(String[] args) {

        CountDownLatch latch = new CountDownLatch(1);
        MyCountDownLatch container = new MyCountDownLatch();// 自定义的容器
        new Thread(() -> {
            if (container.size() != 5) {
                try {
                    latch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("thread2 - end");
        }).start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                if (container.size() == 5) {
                    latch.countDown();
                }
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("thread1 - add");
                container.add(new Object());
            }
        }).start();
    }
}

运行结果

代码分析：

CountDownLatch的构造函数接收一个int类型的参数作为计数器，如果你想等待N个点完成，这里就传入N。当我们调用CountDownLatch的countDown方法时，N就会减1，CountDownLatch的await方法会阻塞当前线程，直到N变成零。

由于countDown方法可以用在任何地方，所以这里说的N个点，可以是N个线程，也可以是1个线程里的N个执行步骤。用在多个线程时，只需要把这个CountDownLatch的引用传递到线程里即可。

源码解读

CountDownLatch 基于 AQS 的共享模式的使用。

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;

public class CountDownLatch {
    private final Sync sync;    // 同步器

    /**
     * 同步计数器的构造方法，传入计数总量
     */
    public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }

    /**
     * 等待计数等于0，如果不为0则进入中断状态
     */
    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

    /**
     * 规定时间内 等待计数等于0，如果不为0则进入中断状态
     * @param timeout 最长等待时间
     * @param unit 时间单位，例如传入TimeUnit.SECONDS
     * @throws InterruptedException
     */
    public boolean await(long timeout, TimeUnit unit)
        throws InterruptedException {
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }

    /**
     * 递减锁计数
     * 如果减到0调用则什么都不会发生
     */
    public void countDown() {
        sync.releaseShared(1);
    }

    /**
     * 返回当前计数
     */
    public long getCount() {
        return sync.getCount(); // 实际上最终调用aqs的getState方法
    }

    /**
     * 返回计数信息的字符串
     */
    public String toString() {
        return super.toString() + "[Count = " + sync.getCount() + "]";
    }

    /**
     * 同步控制计数器
     */
    private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;
        Sync(int count) {
            setState(count); // 给aqs设置state值
        }

        int getCount() {
            return getState(); // 调用aqs中的方法得到state值
        }

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

        protected boolean tryReleaseShared(int releases) {
            // 递减计数，直到计数等于0返回
            for (;;) {
                int c = getState();//获取state值
                if (c == 0)
                    return false;// 返回
                int nextc = c - 1;
                if (compareAndSetState(c, nextc)) // 将计数器更新
                    return nextc == 0;
            }
        }
    }
}

本文小结

CountDownLatch闭锁，中文也可以翻译成门闩，倒计时器等，本文介绍了CountDownLatch的基本概念，应用场景以及实例分析，最后解读了源码。