CountDownLatch理论+实战

1.背景：

• countDownLatch是在java1.5被引入，跟它一起被引入的工具类还有CyclicBarrier、Semaphore、concurrentHashMap和BlockingQueue。
• 存在于java.util.cucurrent包下。

2.概念

• countDownLatch这个类使一个线程等待其他线程各自执行完毕后再执行。
• 是通过一个计数器来实现的，计数器的初始值是线程的数量。每当一个线程执行完毕后，计数器的值就-1，当计数器的值为0时，表示所有线程都执行完毕，然后在闭锁上等待的线程就可以恢复工作了。

3.源码

• countDownLatch类中只提供了一个构造器：

//参数count为计数值
public CountDownLatch(int count) {  };  

• 类中有三个方法是最重要的：

//调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
public void await() throws InterruptedException { };   
//和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };  
//将count值减1
public void countDown() { };  

4.测试demo1

public static void main(String[] args) {


    CountDownLatch countDownLatch = new CountDownLatch(2);

    ExecutorService es1 = Executors.newSingleThreadExecutor();
    es1.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println("线程1号开始等待....");
            try {
                Thread.sleep(2000L);
                countDownLatch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程1号执行完毕....");
        }
    });

    ExecutorService es2 = Executors.newSingleThreadExecutor();
    es2.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println("线程2号开始等待....");
            try {
                Thread.sleep(4000L);
                countDownLatch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程2号执行完毕....");
        }
    });

    try {
        countDownLatch.await();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("主线程开始执行....");

    //    结果：
    //    线程1号开始等待....
    //线程2号开始等待....
    //线程1号执行完毕....
    //线程2号执行完毕....
    //主线程开始执行....
//    2号线程执行完毕，主线程立即执行
}

在main（主线程）中使用

CountDownLatch countDownLatch = new CountDownLatch(2);

实质是代表：

countDownLatch.await( );

该方法会阻塞线程（当前线程为主线程），

等countDownLatch.countDown( );

被执行两次后，才会放开。

所以以上代码的执行效果是：

线程1号开始等待....
线程2号开始等待....

这两行字会立即出现，因为是异步提交任务，不会影响主线程进行。

此时主线程会阻塞等待

2s后

线程1号执行完毕....

这行字出现，因为1号线程沉睡2s

又2s后

线程2号开始等待....

这行字出现，因为2号线程沉睡4s

同时

主线程开始执行....

出现，因为2号线程一致性，countDownLatch.countDown 也就被放开了

主线程就开始执行了

5.测试demo2

public class TestCountDownLatch2 {
    public static final CountDownLatch countDownLatch = new CountDownLatch(2);
    ;

    public static void main(String[] args) {
        ExecutorService es1 = Executors.newSingleThreadExecutor();
        ExecutorService es2 = Executors.newSingleThreadExecutor();
        ExecutorService es3 = Executors.newSingleThreadExecutor();

        es1.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    countDownLatch.await();
                    System.out.println("es1开始执行了...");
                    Thread.sleep(2000L);
                    System.out.println("es1执行结束...");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });
        es2.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("es2正在执行中...");
                    Thread.sleep(2000L);
                    countDownLatch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("es2执行结束...");
            }
        });
        es3.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("es3正在执行中...");
                    Thread.sleep(4000L);
                    countDownLatch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("es3执行结束...");
            }
        });

        //    结果：
        //    es2正在执行中...
        //es3正在执行中...
        //es2执行结束...
        //es3执行结束...
        //es1开始执行了...
        //es1执行结束...
    }
}

这个demo更直观一些。coundDownLatch锁住的是es1的异步任务，而

countDownLatch.countDown();

在es2和es3中分别各执行一次

效果：

//    es2正在执行中...
    //es3正在执行中...

提交异步任务，不会阻塞主线程，所以这两行立即出现

2s后

​ //es2执行结束…

这行出现

又2s后

​ //es3执行结束…

这行出现，之后锁被释放，es1开始执行：

    //es1开始执行了...

又2s后，es1也执行结束

​ //es1执行结束…