CountDownLatch的理解和使用

CountDownLatch是一个同步工具类，用来协调多个线程之间的同步，或者说起到线程之间的通信在日常开发中经常会遇到需要在主线程中开启多个线程去并行执行任务，并且主线程需要等待所有子线程执行完毕后再进行汇总的场景。在CountDownLatch出现之前一般都使用线程的join（）方法来实现这一点，但是join方法不够灵活，不能够满足不同场景的需要，所以JDK开发组提供了CountDownLatch这个类，我们前面介绍的例子使用CountDownLatch会更优雅。使用CountDownLatch的代码如下：

package com.cyc.mystudy.demo06;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @Author cyc
 * @create 2022/7/28 14:29
 */
public class TestCountDownLatch {

    public static void main(String[] args) {
        CountDownLatch countDownLatch = new CountDownLatch(2);
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

                System.out.println("线程A--->end");
                countDownLatch.countDown();
            }
        });
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("线程B--->end");
                countDownLatch.countDown();
            }
        });
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("main结束");
    }
}

运行结果:

1. 在如上代码中，创建了一个CountDownLatch实例，
2. 因为有两个子线程所以构造函数的传参为2。
3. 主线程调用countDownLatch.await（）方法后会被阻塞。
4. 子线程执行完毕后调用countDownLatch.countDown（）方法让countDownLatch内部的计数器减1，所有子线程执行完毕并调用countDown（）方法后计数器会变为0，这时候主线程的await（）方法才会返回。

 当然使用join()也可以实现相同的效果 代码如下:

package com.cyc.mystudy.demo06;

/**
 * @Author cyc
 * @create 2022/7/28 14:29
 */
public class TestCountDownLatch {

    public static void main(String[] args) throws InterruptedException {


        Thread threadA = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            System.out.println("线程A--->end");
        });

        Thread threadB = new Thread(() -> {
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            System.out.println("线程B--->end");
        });
        threadA.start();
        threadB.start();
        threadA.join();
        threadB.join();
        System.out.println("main结束");
    }
}

运行截图:

CountDownLatch与join方法的区别:

1. 调用一个子线程的join（）方法后，该线程会一直被阻塞直到子线程运行完毕
2. 而CountDownLatch则使用计数器来允许子线程运行完毕或者在运行中递减计数，也就是CountDownLatch可以在子线程运行的任何时候让await方法返回而不一定必须等到线程结束。
3. CountDownLatch使用更加灵活,使用线程池时无法使用join()