Java多线程编程-（6）-两种常用的线程计数器CountDownLatch和循环屏障CyclicBarrier

╰半橙微兮° 2021-09-28 01:40 168阅读 0赞

> 原文出自 : [https://blog.csdn.net/xlgen157387/article/details/78218736][https_blog.csdn.net_xlgen157387_article_details_78218736]

## 倒计时CountDownLatch ##

CountDownLatch是一个非常实用的多线程控制工具类，称之为“倒计时器”，它允许一个或多个线程一直等待，直到其他线程的操作执行完后再执行。

举了例子：

我们知道的集齐七颗龙珠就可以召唤神龙，那我们就一起召唤一下，下边我需要派7个人（7个线程）去分别去找这7颗不同的龙珠，每个人找到之后回来告诉我还需要等待的龙珠个数减1个，那么当全部的人都找到龙珠之后，那么我就可以召唤神龙了。

顺便写个代码如下：

public class SummonDragonDemo {
    
        private static final int THREAD_COUNT_NUM = 7;
        private static CountDownLatch countDownLatch = new CountDownLatch(THREAD_COUNT_NUM);
    
        public static void main(String[] args) throws InterruptedException {
    
            for (int i = 1; i <= THREAD_COUNT_NUM; i++) {
                int index = i;
                new Thread(() -> {
                    try {
                        System.out.println("第" + index + "颗龙珠已收集到！");
                        //模拟收集第i个龙珠,随机模拟不同的寻找时间
                        Thread.sleep(new Random().nextInt(3000));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //每收集到一颗龙珠,需要等待的颗数减1
                    countDownLatch.countDown();
                }).start();
            }
            //等待检查，即上述7个线程执行完毕之后，执行await后边的代码
            countDownLatch.await();
            System.out.println("集齐七颗龙珠！召唤神龙！");
        }
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26

运行结果如下：

第7颗龙珠已收集到！
    第2颗龙珠已收集到！
    第6颗龙珠已收集到！
    第3颗龙珠已收集到！
    第5颗龙珠已收集到！
    第4颗龙珠已收集到！
    第1颗龙珠已收集到！
    集齐七颗龙珠！召唤神龙！
     
      
       1
       2
       3
       4
       5
       6
       7
       8

上述的执行结果可以看出，当分配的7个人（7个线程）分别找到龙珠之后，也就是所有的线程执行完毕，才可以召唤龙珠（执行countDownLatch.await()之后的代码）。

注意：

（1）CountDownLatch的构造函数

CountDownLatch countDownLatch = new CountDownLatch(7);
     
      
       1

7表示需要等待执行完毕的线程数量。

（2）在每一个线程执行完毕之后，都需要执行`countDownLatch.countDown()`方法，不然计数器就不会准确；

（3）只有所有的线程执行完毕之后，才会执行 `countDownLatch.await()`之后的代码；

（4）可以看出上述代码中CountDownLatch 阻塞的是主线程；

那么，假如我们不是用计数器CountDownLatch的话，结果可想而知，示例如下：

public class SummonDragonDemo {
    
        private static final int THREAD_COUNT_NUM = 7;
    
        public static void main(String[] args) throws InterruptedException {
    
            for (int i = 1; i <= THREAD_COUNT_NUM; i++) {
                int index = i;
                new Thread(() -> {
                    try {
                        System.out.println("第" + index + "颗龙珠已收集到！");
                        //模拟收集第i个龙珠,随机模拟不同的寻找时间
                        Thread.sleep(Thread.sleep(Math.abs(new Random().nextInt(3000))););
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }).start();
            }
            System.out.println("集齐七颗龙珠！召唤神龙！");
        }
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21

执行结果如下：

第1颗龙珠已收集到！
    集齐七颗龙珠！召唤神龙！
    第2颗龙珠已收集到！
    第3颗龙珠已收集到！
    第4颗龙珠已收集到！
    第5颗龙珠已收集到！
    第6颗龙珠已收集到！
    第7颗龙珠已收集到！
     
      
       1
       2
       3
       4
       5
       6
       7
       8

结果只能呵呵了！

好啦！上边说了一堆水话，下面说点官方的解释：

CountDownLatch是在java1.5被引入的，它存在于java.util.concurrent包下。CountDownLatch这个类能够使一个线程等待其他线程完成各自的工作后再执行。例如，应用程序的主线程希望在负责启动框架服务的线程已经启动所有的框架服务之后再执行。

CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。

![这里写图片描述][20171012195131268]

CountDownLatch.java类中定义的构造函数：

public CountDownLatch(int count) { ... }
     
      
       1

构造器中的计数值（count）实际上就是闭锁需要等待的线程数量。这个值只能被设置一次，而且CountDownLatch没有提供任何机制去重新设置这个计数值。

与CountDownLatch的第一次交互是主线程等待其他线程。主线程必须在启动其他线程后立即调用CountDownLatch.await()方法。这样主线程的操作就会在这个方法上阻塞，直到其他线程完成各自的任务。

其他N 个线程必须引用闭锁对象，因为他们需要通知CountDownLatch对象，他们已经完成了各自的任务。这种通知机制是通过 CountDownLatch.countDown()方法来完成的；每调用一次这个方法，在构造函数中初始化的count值就减1。所以当N个线程都调用了这个方法，count的值等于0，然后主线程就能通过await()方法，恢复执行自己的任务。

## CountDownLatch在实时系统中的使用场景 ##

让我们尝试罗列出在java实时系统中CountDownLatch都有哪些使用场景。我所罗列的都是我所能想到的。如果你有别的可能的使用方法，请在留言里列出来，这样会帮助到大家。

（1）**实现最大的并行性**：有时我们想同时启动多个线程，实现最大程度的并行性。例如，我们想测试一个单例类。如果我们创建一个初始计数为1的CountDownLatch，并让所有线程都在这个锁上等待，那么我们可以很轻松地完成测试。我们只需调用 一次countDown()方法就可以让所有的等待线程同时恢复执行。

（2）**开始执行前等待n个线程完成各自任务**：例如应用程序启动类要确保在处理用户请求前，所有N个外部系统已经启动和运行了。

（3）**死锁检测**：一个非常方便的使用场景是，你可以使用n个线程访问共享资源，在每次测试阶段的线程数目是不同的，并尝试产生死锁。

## 循环屏障CyclicBarrier ##

CyclicBarrier是另一种多线程并发控制使用工具，和CountDownLatch非常类似，他也可以实现线程间的计数等待，但他的功能要比CountDownLatch更加强大一些。

CyclicBarrier 的字面意思是**可循环使用（Cyclic）的屏障（Barrier）**。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。

CyclicBarrier默认的构造方法是`CyclicBarrier(int parties)`，**其参数表示屏障拦截的线程数量**，每个线程调用`await`方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞。

CyclicBarrier强调的是n个线程，大家相互等待，只要有一个没完成，所有人都得等着。

还接着上述“集齐七颗龙珠！召唤神龙”的故事。召唤神龙，需要7个法师去寻找龙珠，但这7个法师并不是一下子就能号召起来的，所以要等待召集齐7个法师，然后在秋名山顶烧香拜佛为这7位法师送行，让他们同时出发，前往不同的地方寻找龙珠（敲黑板：这是第一个屏障点），在这七位法师临行时约定找到龙珠之后还回到这个地方等待其他法师找到龙珠之后一起去见我。几年之后，第一个法师回来了，然后等待其他的法师。。。，最后所有的法师全部到齐（敲黑板：这是第一个屏障点），然后组队来找我召唤神龙。

示例代码如下：

public class SummonDragonDemo { 
    
        private static final int THREAD_COUNT_NUM = 7;
    
        public static void main(String[] args) {
    
            //设置第一个屏障点，等待召集齐7位法师
            CyclicBarrier callMasterBarrier = new CyclicBarrier(THREAD_COUNT_NUM, new Runnable() {
                @Override
                public void run() {
                    System.out.println("7个法师召集完毕，同时出发，去往不同地方寻找龙珠！");
                    summonDragon();
                }
            });
            //召集齐7位法师
            for (int i = 1; i <= THREAD_COUNT_NUM; i++) {
                int index = i;
                new Thread(() -> {
                    try {
                        System.out.println("召集第" + index + "个法师");
                        callMasterBarrier.await();
                    } catch (InterruptedException | BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }).start();
            }
        }
    
        /** * 召唤神龙：1、收集龙珠；2、召唤神龙 */
        private static void summonDragon() {
            //设置第二个屏障点，等待7位法师收集完7颗龙珠，召唤神龙
            CyclicBarrier summonDragonBarrier = new CyclicBarrier(THREAD_COUNT_NUM, new Runnable() {
                @Override
                public void run() {
                    System.out.println("集齐七颗龙珠！召唤神龙！");
                }
            });
            //收集7颗龙珠
            for (int i = 1; i <= THREAD_COUNT_NUM; i++) {
                int index = i;
                new Thread(() -> {
                    try {
                        System.out.println("第" + index + "颗龙珠已收集到！");
                        summonDragonBarrier.await();
                    } catch (InterruptedException | BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }).start();
            }
        }
    }
    
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38
       39
       40
       41
       42
       43
       44
       45
       46
       47
       48
       49
       50
       51
       52
       53
       54

执行结果：

召集第2个法师
    召集第1个法师
    召集第3个法师
    召集第4个法师
    召集第6个法师
    召集第5个法师
    召集第7个法师
    7个法师召集完毕，同时出发，去往不同地方寻找龙珠！
    第1颗龙珠已收集到！
    第2颗龙珠已收集到！
    第3颗龙珠已收集到！
    第4颗龙珠已收集到！
    第5颗龙珠已收集到！
    第6颗龙珠已收集到！
    第7颗龙珠已收集到！
    集齐七颗龙珠！召唤神龙！
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16

代码中设置了两个屏障点，第一个用于召集7个法师，等7个法师召集完后，在设置在一个屏障点，7位法师去寻找龙珠，然后召唤神龙，中间有个嵌套的关系！

上述的例子，大致说了一下屏障，因为设置了两个屏障，并没有演示上述说的**可循环使用（Cyclic）的屏障（Barrier）** 中的可循环使用（Cyclic）

/**
         * Resets the barrier to its initial state.  If any parties are
         * currently waiting at the barrier, they will return with a
         * {@link BrokenBarrierException}. Note that resets <em>after</em>
         * a breakage has occurred for other reasons can be complicated to
         * carry out; threads need to re-synchronize in some other way,
         * and choose one to perform the reset.  It may be preferable to
         * instead create a new barrier for subsequent use.
         */
        public void reset() { ... }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10

查看`CyclicBarrier.reset()` 可知，可以使CyclicBarrier回到最初始的状态，由于使用的相对较少，这里不再演示。

## CyclicBarrier和CountDownLatch的区别 ##

（1）CountDownLatch的计数器只能使用一次。而CyclicBarrier的计数器可以使用reset() 方法重置。所以CyclicBarrier能处理更为复杂的业务场景，比如如果计算发生错误，可以重置计数器，并让线程们重新执行一次。

（2）CyclicBarrier还提供其他有用的方法，比如getNumberWaiting方法可以获得CyclicBarrier阻塞的线程数量。isBroken方法用来知道阻塞的线程是否被中断。比如以下代码执行完之后会返回true。

（3）CountDownLatch会阻塞主线程，CyclicBarrier不会阻塞主线程，只会阻塞子线程。

--------------------

参考文章：

1、[http://www.importnew.com/15731.html][http_www.importnew.com_15731.html]

[https_blog.csdn.net_xlgen157387_article_details_78218736]: https://blog.csdn.net/xlgen157387/article/details/78218736
[20171012195131268]: /images/20210923/4ac5075eb23f4ef28e222ad0428c491d.png
[http_www.importnew.com_15731.html]: http://www.importnew.com/15731.html