读懂本篇文章带你快速理解CountDownLatch

刺骨的言语ヽ痛彻心扉 2023-03-13 12:20 14阅读 0赞

## CountDownLatch概念 ##

countDownLatch是一个同步工具类，用来协调多个线程之间的同步，或者说起线程之间的通信（而不是用作互斥的作用）

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

## CountDownLatch的用法 ##

*  CountDownLatch典型用法：

1，某一线程在开始运行前等待n个线程执行完毕。将CountDownLatch的计数器初始话为new CountDownLatch(n),每当一个任务执行完毕，就将计数器减1  
countdownLatch.countDown(),当计数器的值变为0时，在CountDownLatch上await（）的线程就会被唤醒。一个典型运用场景就是启动一个服务时，主线程需要等待多个组件加载完毕，之后再继续执行。

2，实现多个线程开始执行任务的最大并行性。注意是并行性，不是并发，强调的是多个线程再某一个时刻同时开始执行。类似于赛跑，将多个线程放到起点，等待发令枪响，然后同时开跑。做法是初始化一个共享的CountDownLatch(1)，将其计算器初始化为1，多个线程在开始执行任务前首先countdownlatch.await()，当主线程调用countDown()时，计数器变为0，多个线程同时被唤醒。

## CountDownLatch的不足 ##

CountDownLatch是一次性的，计算器的值只能在构造方法中初始化一次，之后没有任何机制再次对其设置值，当CountDownLatch使用完毕后，它不能再次被使用。

例子一：  
主线程等待子线程执行完毕后 在执行

package com.evan.springboot.concurrentDemo;
    
    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /**
     * @author evanYang
     * @version 1.0
     * @date 2020/5/13 下午 5:29
     */
    public class CountDownLatchDemo { 
        public static void main(String[] args) { 
            ExecutorService executorService = Executors.newFixedThreadPool(3);
            CountDownLatch countDownLatch = new CountDownLatch(3);
            for (int i = 0; i < 3; i++) { 
                Runnable runnable = new Runnable(){ 
                    @Override
                    public void run() { 
                        try { 
                            System.out.println("子线程"+Thread.currentThread().getName()+"开始执行");
                            Thread.sleep(1000);
                            System.out.println("子线程"+Thread.currentThread().getName()+"子线程执行完成");
                            countDownLatch.countDown();
                        } catch (InterruptedException e) { 
                            e.printStackTrace();
                        }
                    }
                };
                executorService.execute(runnable);
            }
            try { 
                System.out.println("主线程"+Thread.currentThread().getName()+"等待子线程执行完毕");
                countDownLatch.await();
                System.out.println("主线程"+Thread.currentThread().getName()+"开始执行");
            }catch (Exception e){ 
                e.printStackTrace();
            }
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zMDQwOTkyNw_size_16_color_FFFFFF_t_70]

例子2：

百米赛跑，4名运动员选手到达场地等待裁判口令，裁判一声口令，选手听到后同时起跑，当所有选手到达终点，裁判进行汇总排名

public static void runDemo(){ 
            ExecutorService executorService = Executors.newCachedThreadPool();
            CountDownLatch latchBegin = new CountDownLatch(1);
            CountDownLatch latchEnd = new CountDownLatch(4);
            for (int i = 0; i < 4; i++) { 
                Runnable runnable = new Runnable(){ 
                    @Override
                    public void run() { 
                        try { 
                            System.out.println("子线程"+Thread.currentThread().getName()+"等待裁判");
                            latchBegin.await();
                            System.out.println("子线程"+Thread.currentThread().getName()+"赛前准备");
                            Thread.sleep((long) (Math.random() * 10000));
                            System.out.println("选手" + Thread.currentThread().getName() + "到达终点");
                            latchEnd.countDown();
                        }catch (Exception e){ 
                            e.printStackTrace();
                        }
                    }
                };
                executorService.execute(runnable);
            }
    
            try { 
                Thread.sleep((long) (Math.random() * 10000));
                System.out.println("裁判到场"+ Thread.currentThread().getName());
                latchBegin.countDown();
                System.out.println("裁判"+Thread.currentThread().getName()+"已发送口令，正在等待所有选手到达终点");
                latchEnd.await();
                System.out.println("所有选手都到达终点");
                System.out.println("裁判"+Thread.currentThread().getName()+"汇总成绩排名");
            }catch (Exception e){ 
                e.printStackTrace();
            }
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zMDQwOTkyNw_size_16_color_FFFFFF_t_70 1]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zMDQwOTkyNw_size_16_color_FFFFFF_t_70]: /images/20230312/53f6df99e6114a4a96be6a339817f48c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zMDQwOTkyNw_size_16_color_FFFFFF_t_70 1]: /images/20230312/352eb5d9ba434b1d8f07ac73382c79a5.png