携手创作，共同生长！这是我参加「日新计划 8 月更文应战」的第11天，点击检查活动概况

CountDownLatch原理

CountDownLatch是经过一个计数器来完结的，计数器的初始化值为线程的数量。每当一个线程完结了自己的使命后，计数器的值就相应得减1。当计数器抵达0时，表示一切的线程都已完结使命，然后在闭锁上等候的线程就能够恢复履行使命。CountDownLatch能够起到堵塞线程，并保证线程在满意某种特定的状况后持续履行。

AQS同步组件-CountDownLatch解析和事例

CountDownLatch 的两种典型用法

  • 某一线程在开端运行前等候n个线程履行结束。将 CountDownLatch 的计数器初始化为n ：new CountDownLatch(n)，每当一个使命线程履行结束，就将计数器减1 countdownlatch.countDown()，当计数器的值变为0时，在CountDownLatch上 await()的线程就会被唤醒。一个典型运用场景就是发动一个服务时，主线程需求等候多个组件加载结束，之后再持续履行。即能够经过初始化，定义线程个数。
  • 完结多个线程开端履行使命的最大并行性。留意是并行性，不是并发，着重的是多个线程在某一时刻一起开端履行。类似于赛跑，将多个线程放到起点，等候发令枪响，然后一起开跑。做法是初始化一个同享的 CountDownLatch 目标，将其计数器初始化为 1 ：new CountDownLatch(1)，多个线程在开端履行使命前首要 coundownlatch.await()，当主线程调用 countDown() 时，计数器变为0，多个线程一起被唤醒。

源码分析

/**
     * 结构器中的计数值(count)实际上就是闭锁需求等候的线程数量。这个值只能被设置一次，
     *而且CountDownLatch没有提供任何机制去从头设置这个计数值。
     *
     * @param count 在线程能够经过 {@link #await} 之前必须调用 {@link #countDown} 的次数
     * @throws IllegalArgumentException 假如给定参数小于0则抛出反常
     */
    public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }

/**
     * 使当时线程等候，直到计数器为零，除非当时线程被中止
     * 1.当时计数为零，则此办法当即回来
     * 2.假如当时计数大于零，则当时线程将因线程调度意图而被禁用并处于休眠状况，
     * 直到发生如下可能：
     *	 由于调用了 {@link #countDown} 办法，计数达到零
     *   线程等候被中止。
     * @throws 假如当时线程在等候时被中止
     */
    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

/**
	 * 能够设置等候时刻，超过这个时刻就会履行，不会比及计数器变为0,可是
     * 之前给定的线程仍是会履行完
     *
     * @param timeout 等候时刻长度
     * @param unit 等候时刻单位
     * @return 
     * @throws 假如当时线程在等候时被中止
     */
public boolean await(long timeout, TimeUnit unit)
    throws InterruptedException {
    return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}

与CountDownLatch的第一次交互是主线程等候其他线程。主线程必须在发动其他线程后当即调用CountDownLatch.await()办法。这样主线程的操作就会在这个办法上堵塞，直到其他线程完结各自的使命。 其他N 个线程必须引用闭锁目标，由于他们需求告诉CountDownLatch目标，他们现已完结了各自的使命。这种告诉机制是经过 CountDownLatch.countDown()办法来完结的;每调用一次这个办法，在结构函数中初始化的count值就减1。所以当N个线程都调用了这个办法，count的值等于0，然后主线程就能经过await()办法，恢复履行自己的使命。 留意：

  • CountDownLatch的结构函数 CountDownLatch countDownLatch = new CountDownLatch(7); //7表示需求等候履行结束的线程数量。
  • 在每一个线程履行结束之后，都需求履行 countDownLatch.countDown() 办法，否则计数器就不会精确;
  • 只要一切的线程履行结束之后，才会履行 countDownLatch.await() 之后的 代码;
  • CountDownLatch 堵塞的是主线程;

CountDownLatch 的运用示例

@Slf4j
public class CountDownLatchExample1 {
    /**
     * 线程数量
     */
    private final static int threadCount = 200;
    public static void main(String[] args) throws Exception {
        ExecutorService exec = Executors.newCachedThreadPool();
        final CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            exec.execute(() -> {
                try {
                    test(threadNum);
                } catch (Exception e) {
                    log.error("exception", e);
                } finally {
                    // 表示一个恳求现已完结
                    countDownLatch.countDown();
                }
            });
        }
        //使当时线程等候，直到计数器为零，除非当时线程被中止
        countDownLatch.await();
        //当这200个恳求被处理完结之后，才会履行
        log.info("finish");
        exec.shutdown();
    }
    private static void test(int threadNum) throws Exception {
        // 模拟恳求的耗时操作
        Thread.sleep(100);
        log.info("{}", threadNum);
        Thread.sleep(100);
    }
}

上面的代码中，咱们定义了恳求的数量为200，当这200个恳求被处理完结之后，才会履行System.out.println(“finish”);。

//能够设置等候时刻，超过这个时刻就会履行，不会比及计数器变为0,可是之前给定的线程仍是会履行完
countDownLatch.await(20, TimeUnit.MILLISECONDS);

上面代码中其他跟第一个代码共同，运用了wait设置等候一定时刻后持续履行办法。

/**
 * CountDownLatch 模拟并发调用多个使命
 *
 * @author zjq
 */
@Slf4j
public class CountDownLatchExample3 {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(2) {
            @Override
            public void await() throws InterruptedException {
                super.await();
                log.info("其他线程履行结束后主线程履行的内容");
                log.info("threadName:{},", Thread.currentThread().getName() + " count down is ok");
            }
        };
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                    log.info(Thread.currentThread().getName() + "使命已完结");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    //计数器减1
                    countDownLatch.countDown();
                }
            }
        }, "thread111");
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000);
                    log.info(Thread.currentThread().getName() + "使命已完结");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    //计数器减1
                    countDownLatch.countDown();
                }
            }
        }, "thread222");
        thread1.start();
        thread2.start();
        countDownLatch.await();
        log.info("====everything is end====");
    }
}

上述代码履行输出成果：

[thread111] INFO com.zjq.concurrency.aqs.CountDownLatchExample3 - thread111使命已完结
[thread222] INFO com.zjq.concurrency.aqs.CountDownLatchExample3 - thread222使命已完结
[main] INFO com.zjq.concurrency.aqs.CountDownLatchExample3 - 其他线程履行结束后主线程履行的内容
[main] INFO com.zjq.concurrency.aqs.CountDownLatchExample3 - threadName:main count down is ok,
[main] INFO com.zjq.concurrency.aqs.CountDownLatchExample3 - ====everything is end====

/**
 * CountDownLatch 模拟多个使命并发履行结束后等候主线程发令一起履行后续操作
 *
 * @author zjq
 */
@Slf4j
public class CountDownLatchExample4 {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(1);
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                try {
                    //一切线程堵塞在这，等候主线程号令
                    log.info(Thread.currentThread().getName() + "已预备结束！！");
                    countDownLatch.await();
                    log.info("【" + Thread.currentThread().getName() + "】" + "开端履行……");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
        // 主线程预备发令
        Thread.sleep(2000);
        log.info(Thread.currentThread().getName() + "指挥若定，给我冲！！");
        // 主线程：履行发令
        countDownLatch.countDown();
    }
}

完结最大并行性输出成果：

[Thread-3] INFO com.zjq.aqs.CountDownLatchExample4 - Thread-3已预备结束！！
[Thread-0] INFO com.zjq.aqs.CountDownLatchExample4 - Thread-0已预备结束！！
[Thread-2] INFO com.zjq.aqs.CountDownLatchExample4 - Thread-2已预备结束！！
[Thread-1] INFO com.zjq.aqs.CountDownLatchExample4 - Thread-1已预备结束！！
[Thread-4] INFO com.zjq.aqs.CountDownLatchExample4 - Thread-4已预备结束！！
[main] INFO com.zjq.aqs.CountDownLatchExample4 - main指挥若定，给我冲！！
[Thread-3] INFO com.zjq.aqs.CountDownLatchExample4 - 【Thread-3】开端履行……
[Thread-1] INFO com.zjq.aqs.CountDownLatchExample4 - 【Thread-1】开端履行……
[Thread-0] INFO com.zjq.aqs.CountDownLatchExample4 - 【Thread-0】开端履行……
[Thread-2] INFO com.zjq.aqs.CountDownLatchExample4 - 【Thread-2】开端履行……
[Thread-4] INFO com.zjq.aqs.CountDownLatchExample4 - 【Thread-4】开端履行……

CountDownLatch 的不足

CountDownLatch是一次性的，计数器的值只能在结构办法中初始化一次，之后没有任何机制再次对其设置值，当CountDownLatch运用结束后，它不能再次被运用。

CountDownLatch运用场景

(1)完结最大的并行性:有时咱们想一起发动多个线程，完结最大程度的并行性。例 如，咱们想测验一个单例类。假如咱们创建一个初始计数为1的CountDownLatch，并 让一切线程都在这个锁上等候，那么咱们能够很轻松地完结测验。咱们只需调用 一次 countDown()办法就能够让一切的等候线程一起恢复履行。 (2)开端履行前等候n个线程完结各自使命:例如运用程序发动类要确保在处理用户 恳求前，一切N个外部系统现已发动和运行了。 (3)死锁检测:一个十分便利的运用场景是，你能够运用n个线程访问同享资源，在每次测验阶段的线程数目是不同的，并测验产生死锁。

本文内容到此结束了，

如有收获欢迎点赞保藏重视✔️，您的鼓舞是我最大的动力。

如有错误❌疑问欢迎各位大佬指出。

主页：共饮一杯无的博客汇总‍

坚持热爱，奔赴下一场山海。

AQS同步组件-CountDownLatch解析和事例