JAVA同步锁CountDownLatch

CountDownLatch介绍

CountDownLatch（闭锁）是一个同步协助类，允许一个或多个线程等待，直到其他线程完成

操作集。

CountDownLatch使用给定的计数值（count）初始化。 await方法会阻塞直到当前的计数值

（count）由于countDown方法的调用达到0，count为0之后所有等待的线程都会被释放，并且随后对await方法的调用都会立即返回。这是一个一次性现象 —— count不会被重置。 如果你需要一个重置count的版本，那么请考虑使用CyclicBarrier。

CountDownLatch的使用

构造器

常用方法

 // 调用 await() 方法的线程会被挂起，它会等待直到 count 值为 0 才继续执行 
public void await() throws InterruptedException { }; 
// 和 await() 类似，若等待 timeout 时长后，count 值还是没有变为 0，不再等待，继续 执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedExceptio n { }; 
// 会将 count 减 1，直至为 0 
public void countDown() { };

 CountDownLatch应用场景

CountDownLatch一般用作多线程倒计时计数器，强制它们等待其他一组（CountDownLatch的初始化决定）任务执行完成。

CountDownLatch的两种使用场景：

• 场景1：让多个线程等待
• 场景2：让单个线程等待。

场景1 让多个线程等待：模拟并发，让并发线程一起执行

/**
 * 让多个线程等待：模拟并发，让并发线程一起执行
 */
public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException {

        CountDownLatch countDownLatch = new CountDownLatch(1);
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                try {
                    //准备完毕……运动员都阻塞在这，等待号令
                    countDownLatch.await();
                    String parter = "【" + Thread.currentThread().getName() + "】";
                    System.out.println(parter + "开始执行……");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }

        Thread.sleep(2000);// 裁判准备发令
        countDownLatch.countDown();// 发令枪：执行发令
    }
}

场景2 让单个线程等待：多个线程(任务)完成后，进行汇总合并

     很多时候，我们的并发任务，存在前后依赖关系；比如数据详情页需要同时调用多个接口获取数据，并发请求获取到数据后、需要进行结果合并；或者多个数据操作完成后，需要数据check；这其实都是：在多个线程(任务)完成后，进行汇总合并的场景。

CountDownLatch countDownLatch = new CountDownLatch(5);
for (int i = 0; i < 5; i++) {
    final int index = i;
    new Thread(() -> {
        try {
            Thread.sleep(1000 +
                    ThreadLocalRandom.current().nextInt(1000));
            System.out.println(Thread.currentThread().getName()
                    + " finish task" + index);

            countDownLatch.countDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }).start();
}



// 主线程在阻塞，当计数器==0，就唤醒主线程往下执行。
countDownLatch.await();
System.out.println("主线程:在所有任务运行完成后，进行结果汇总");

CountDownLatch实现原理

      底层基于 AbstractQueuedSynchronizer 实现，CountDownLatch 构造函数中指定的count直接赋给AQS的state； 每次countDown()则都是release(1)减1，最后减到0时unpark唤醒队列中所有线程；这一步是由最后一个执行countdown方法的线程执行的。

      而调用await()方法时，当前线程就会判断state属性是否为0，如果为0，则不阻塞当前线程继续往下执行；如果不为0，则将线程加入等待队列并挂起当前线程，直到某个线程将state属性置为0，其就会唤醒在await()方法中等待的线程。

CountDownLatch与Thread.join的区别

• CountDownLatch的作用就是允许一个或多个线程等待其他线程完成操作，看起来有点类似join() 方法，但其提供了比 join() 更加灵活的API。
• CountDownLatch可以手动控制在n个线程里调用n次countDown()方法使计数器进行减一操作，也可以在一个线程里调用n次执行减一操作。
• 而 join() 的实现原理是不停检查join线程是否存活，如果 join 线程存活则让当前线程永远等待。所以两者之间相对来说还是CountDownLatch使用起来较为灵活。