CountDownLatch用法

小咪咪 2022-05-15 02:51 198阅读 0赞

官方定义：A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.  
有道翻译：一种同步辅助程序，允许一个或多个线程等待，直到在其他线程中执行的一组操作完成。

个人理解，实际就是一个倒计时计数器，人为指定计数器的起始值，从起始值开始倒计时计数。  
主要方法：

await():阻塞，直到倒计时为0开始执行;
    countDown():倒计时方法，没执行一次减一，如果新计数为零，则所有等待的线程都将被重新启用;
    getCount():返回当前计数。

说这么多，也不知道到底是个啥，看例子：  
**例1：**  
三个运动员百米赛跑，一个裁判倒计时发枪。裁判需要等待运动员全部都准备好了，才会发枪  
所以这段时间裁判需要除以等待状态，当所有的运动员都汇报准备好了，裁判发枪

//也就是说await()会一直等待CountDownLatch的初始值全部countDown()后才会线下执行
    public static void main(String[] args) {
    
            CountDownLatch latch = new CountDownLatch(3);
    
            Thread t1 = new Thread(new Runnable() {
                public void run() {
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("博尔特准备完毕");
                    latch.countDown();
                    System.out.println("剩下的记数器:"+latch.getCount());
                }
            },"t1");
    
            Thread t2 = new Thread(new Runnable() {
                public void run() {
                    try {
                        Thread.sleep(7000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("加特林准备完毕");
                    latch.countDown();
                    System.out.println("剩下的记数器:"+latch.getCount());
                }
            },"t2");
    
            Thread t3 = new Thread(new Runnable() {
                public void run() {
                    try {
                        Thread.sleep(10000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("鲍威尔准备完毕");
                    latch.countDown();
                    System.out.println("剩下的记数器:"+latch.getCount());
                }
            },"t3");
    
            t1.start();
            t2.start();
            t3.start();
    
            try {
                System.out.println("我是裁判，你们好好准备，准备好了都说一声....");
                latch.await();
                System.out.println("好的，都准备好了，我要发枪了");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

运行结果:

我是裁判，你们好好准备，准备好了都说一声...
    博尔特准备完毕
    剩下的记数器:2
    加特林准备完毕
    剩下的记数器:1
    鲍威尔准备完毕
    剩下的记数器:0
    好的，都准备好了，我要发枪了

**例2：**  
其实刚才说的是裁判等运动员准备的过程，实际上细细分析，我们会发现，实际上也有一个运动员等枪响的动作。运动员听见枪响后，同时起跑。

public static void main(String[] args) {
            CountDownLatch latch = new CountDownLatch(1);
    
            Thread t1 = new Thread(new Runnable() {
                public void run() {
                    try {
                        latch.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("博尔特起跑");
                }
            },"t1");
    
            Thread t2 = new Thread(new Runnable() {
                public void run() {
                    try {
                        latch.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("鲍威尔起跑");
                }
            },"t2");
    
            Thread t3 = new Thread(new Runnable() {
                public void run() {
                    try {
                        latch.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("加特林起跑");
                }
            },"t3");
    
            t1.start();
            t2.start();
            t3.start();
    
            try {
                System.out.println("各就位");
                Thread.sleep(3000);
                System.out.println("发枪....");
                latch.countDown();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

运行结果：

各就位
    发枪....
    博尔特起跑
    加特林起跑
    鲍威尔起跑

**例3**

模拟发枪起跑，到运动员跑完全程，比赛结束的过程：

public static void main(String[] args) {
    
            CountDownLatch start = new CountDownLatch(1);
            CountDownLatch end = new CountDownLatch(3);
    
            Thread t1 = new Thread(new Runnable() {
                public void run() {
                    try {
                        start.await();
                        System.out.println("博尔特起跑");
    
                        Thread.sleep(9580);
    
                        System.out.println("博尔特跑完了全程");
                        end.countDown();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            },"t1");
    
            Thread t2 = new Thread(new Runnable() {
                public void run() {
                    try {
                        start.await();
                        System.out.println("鲍威尔起跑");
    
                        Thread.sleep(9760);
    
                        System.out.println("鲍威尔跑完了全程");
                        end.countDown();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            },"t2");
    
            Thread t3 = new Thread(new Runnable() {
                public void run() {
                    try {
                        start.await();
                        System.out.println("加特林起跑");
    
                        Thread.sleep(9620);
    
                        System.out.println("加特林跑完了全程");
                        end.countDown();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            },"t3");
    
            t1.start();
            t2.start();
            t3.start();
    
            try {
                System.out.println("各就位");
                Thread.sleep(1000);
                System.out.println("发枪.....");
                start.countDown();
                Thread.sleep(2000);
                System.out.println("这是一场精彩的比赛");
                Thread.sleep(2000);
                System.out.println("加特林加速");
                Thread.sleep(2000);
                System.out.println("博尔特反超");
                Thread.sleep(2000);
                System.out.println("博尔特一直保持领先");
    
                end.await();
                System.out.println("比赛结束");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
        }

运行结果：

各就位
    发枪.....
    鲍威尔起跑
    加特林起跑
    博尔特起跑
    这是一场精彩的比赛
    加特林加速
    博尔特反超
    博尔特一直保持领先
    博尔特跑完了全程
    加特林跑完了全程
    鲍威尔跑完了全程
    比赛结束

相信已经基本理解了CountDownLatch用法了吧