两种常用的线程计数器CountDownLatch和循环屏障CyclicBarrier

最新推荐文章于 2024-06-06 17:42:58 发布

Winn~

最新推荐文章于 2024-06-06 17:42:58 发布

阅读量461

点赞数 1

分类专栏： Java 文章标签：多线程

Java 专栏收录该内容

112 篇文章 5 订阅

订阅专栏

一、倒计时CountDownLatch

CountDownLatch是一个非常实用的多线程控制工具类，称之为“倒计时器”，它允许一个或多个线程一直等待，直到其他线程的操作执行完后再执行。
举了例子：
我们知道的集齐七颗龙珠就可以召唤神龙，那我们就一起召唤一下，下边我需要派7个人（7个线程）去分别去找这7颗不同的龙珠，每个人找到之后回来告诉我还需要等待的龙珠个数减1个，那么当全部的人都找到龙珠之后，那么我就可以召唤神龙了。
顺便写个代码如下：

import java.util.Random;
import java.util.concurrent.CountDownLatch;

public class CountDownLatchTest {
    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 = 0; i < THREAD_COUNT_NUM; i++) {
             final int index = i;
            new Thread(new Runnable() {

                @Override
                public void run() {
                    try {
                        System.out.println("第" + index + "颗龙珠已收集到！");
                        // 随机模拟不同的寻找时间
                        Thread.sleep(new Random().nextInt(3000));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 每收集一颗龙珠，需要等待的颗数减1
                    countDownLatch.countDown();

                }
            }).start();
        }
        // 等待检查，即上述7个线程执行完毕之后，执行await后边的代码
        countDownLatch.await();
        System.out.println("集齐七科龙珠！召唤神龙！");
    }
}

运行结果：
这里写图片描述

运行分析：

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

7表示需要等待执行完毕的线程数量。
（2）在每一个线程执行完毕之后，都需要执行countDownLatch.countDown()方法，不然计数器就不会准确；
（3）只有所有的线程执行完毕之后，才会执行 countDownLatch.await()之后的代码；
（4）可以看出上述代码中CountDownLatch 阻塞的是主线程；

官方解释：

CountDownLatch是在java1.5被引入的，它存在于java.util.concurrent包下。CountDownLatch这个类能够使一个线程等待其他线程完成各自的工作后再执行。例如，应用程序的主线程希望在负责启动框架服务的线程已经启动所有的框架服务之后再执行。
CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。

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

构造器中的计数值（count）实际上就是闭锁需要等待的线程数量。这个值只能被设置一次，而且CountDownLatch没有提供任何机制去重新设置这个计数值。
与CountDownLatch的第一次交互是主线程等待其他线程。主线程必须在启动其他线程后立即调用CountDownLatch.await()方法。这样主线程的操作就会在这个方法上阻塞，直到其他线程完成各自的任务。
其他N 个线程必须引用闭锁对象，因为他们需要通知CountDownLatch对象，他们已经完成了各自的任务。这种通知机制是通过
CountDownLatch.countDown()方法来完成的；每调用一次这个方法，在构造函数中初始化的count值就减1。所以当N个线程都调用了这个方法，count的值等于0，然后主线程就能通过await()方法，恢复执行自己的任务。

二、循环屏障CyclicBarrier

CyclicBarrier是另一种多线程并发控制使用工具，和CountDownLatch非常类似，他也可以实现线程间的计数等待，但他的功能要比CountDownLatch更加强大一些。
CyclicBarrier 的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。
CyclicBarrier默认的构造方法是CyclicBarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞。
CyclicBarrier强调的是n个线程，大家相互等待，只要有一个没完成，所有人都得等着。
还接着上述“集齐七颗龙珠！召唤神龙”的故事。召唤神龙，需要7个法师去寻找龙珠，但这7个法师并不是一下子就能号召起来的，所以要等待召集齐7个法师，然后在秋名山顶烧香拜佛为这7位法师送行，让他们同时出发，前往不同的地方寻找龙珠（敲黑板：这是第一个屏障点），在这七位法师临行时约定找到龙珠之后还回到这个地方等待其他法师找到龙珠之后一起去见我。几年之后，第一个法师回来了，然后等待其他的法师。。。，最后所有的法师全部到齐（敲黑板：这是第一个屏障点），然后组队来找我召唤神龙。
示例代码如下：

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * 
 * 项目名称：test_java 类名称：CyclicBarrierTest 类描述： 创建人：SuWL 创建时间：2017-10-20 上午9:46:04
 * 修改人：SuWL 修改时间：2017-10-20 上午9:46:04 修改备注：
 * 
 * @version
 * 
 */
public class CyclicBarrierTest {
    private static final int THREAD_COUNT_NUM = 7;

    public static void main(String[] args){
        //设置第一个屏障点，等待召集齐7位法师
        final CyclicBarrier callMasterBarrier =new CyclicBarrier(THREAD_COUNT_NUM, new Runnable(){
            @Override
            public void run(){
                System.out.println("7个法师召集完毕，同时出发，去往不同地方寻找龙珠！");
                summonDragon();
            }
        });
        //召集7位法师
        for (int i = 0; i < THREAD_COUNT_NUM; i++) {
            final int index = i;
            new Thread(new Runnable(){
                    @Override
                    public void run() {
                        try{
                            System.out.println("召集第" + index + "个法师");
                            callMasterBarrier.await();
                        }catch(InterruptedException e){
                            e.printStackTrace();
                        } 
                        catch(BrokenBarrierException e){
                            e.printStackTrace();
                        } 

                    }
                    }).start();
        }
    }

    /**
     * 召唤神龙：1、收集龙珠；2、召唤神龙
     * */
    private static void summonDragon(){
        final CyclicBarrier summonDragonBarrier = new CyclicBarrier(THREAD_COUNT_NUM, new Runnable(){
            @Override
            public void run(){
                System.out.println("集齐7颗龙珠，召唤神龙！");

            }
        });
        //收集7颗龙珠
        for (int i = 0; i < THREAD_COUNT_NUM; i++) {
            final int index = i;
            new Thread(new Runnable(){

                @Override
                public void run() {
                    try{
                        System.out.println("第"+index+ "颗龙珠已收集到！");
                        summonDragonBarrier.await();
                    }
                    catch(InterruptedException e){
                        e.printStackTrace();
                    }
                    catch(BrokenBarrierException e){
                        e.printStackTrace();
                    }

                }
            }).start();
        }
    }
}

运行结果：
这里写图片描述
代码中设置了两个屏障点，第一个用于召集7个法师，等7个法师召集完后，在设置在一个屏障点，7位法师去寻找龙珠，然后召唤神龙，中间有个嵌套的关系！

总结：CyclicBarrier和CountDownLatch的区别

（1）CountDownLatch的计数器只能使用一次。而CyclicBarrier的计数器可以使用reset() 方法重置。所以CyclicBarrier能处理更为复杂的业务场景，比如如果计算发生错误，可以重置计数器，并让线程们重新执行一次。
（2）CyclicBarrier还提供其他有用的方法，比如getNumberWaiting方法可以获得CyclicBarrier阻塞的线程数量。isBroken方法用来知道阻塞的线程是否被中断。比如以下代码执行完之后会返回true。
（3）CountDownLatch会阻塞主线程，CyclicBarrier不会阻塞主线程，只会阻塞子线程。