JAVA并发编程：线程并发工具类CountDownLatch与CyclicBarrier的作用、应用场景和实战

最新推荐文章于 2021-12-10 20:48:34 发布

菜鸟技术栈

最新推荐文章于 2021-12-10 20:48:34 发布

阅读量392

点赞数 1

分类专栏：并发编程 Java

本文链接：https://blog.csdn.net/lspj201007186/article/details/106196436

版权

Java 同时被 2 个专栏收录

39 篇文章 1 订阅

订阅专栏

并发编程

14 篇文章 0 订阅

订阅专栏

一、CountDownLatch

1、基本概念及作用

JDK解释：A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.

闭锁，CountDownLatch 这个类能够使一个线程等待一个或多个线程完成各自的工作后再执行。
CountDownLatch 是通过一个计数器来实现的，计数器的初始值为初始任务的数量。每当完成了一个任务后，计数器的值就会减1，调用CountDownLatch类的countDown()方法。调用CountDownLatch类的await()方法，线程在闭锁上等待。当计数器值到达0 时，表示所有的其他线程已经完成了任务，然后在闭锁上等待CountDownLatch.await()方法的线程就可以恢复执行任务。

2、应用场景

实现最大的并行性：有时我们想同时启动多个线程，实现最大程度的并行性。
例如，我们想测试一个单例类。如果我们创建一个初始计数为1 的CountDownLatch，并让所有线程都在这个锁上等待，那么我们可以很轻松地完成测试。我们只需调用一次countDown()方法就可以让所有的等待线程同时恢复执行。
开始执行前等待n 个线程完成各自任务：例如应用程序启动类要确保在处理用户请求前，所有N 个外部系统已经启动和运行了，例如处理excel 中多个表单。

如下图所示，比如有两个线程TW1、TW2需要一直wait Ta、Tb、Tc、Td 4个线程执行完相应业务后调用countDown()方法扣减count，当count被扣减为0时，TW1、TW2线程再执行后面的业务逻辑。需要特别注意的是使用CountDownLatch时调用countDown()方法执行扣减count的线程数和CountDownLatch初始化的count数不需要保持一致，比如在Td同一个线程内可以扣减2次count。
在这里插入图片描述

3、代码示例

类说明：演示CountDownLatch用法，共4个初始化子线程，5个闭锁扣除点，扣除完毕后，主线程和业务线程才能继续执行。

package cn.lspj.ch2.tools;

import java.util.concurrent.CountDownLatch;

/**
 *类说明：演示CountDownLatch用法，
 * 共4个初始化子线程，5个闭锁扣除点，扣除完毕后，主线程和业务线程才能继续执行
 */
public class CountDownLatchToExample {

    private static CountDownLatch latch = new CountDownLatch(5);

    static class initialTask implements Runnable {
        @Override
        public void run() {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ",initialTask ready initial work...");
            latch.countDown();
            System.out.println(Thread.currentThread().getName() + ",initialTask contine do other work");
        }
    }

    /**
     * 业务线程等待latch的计数器为0时执行
     */
    static class BusiTask implements Runnable {
        @Override
        public void run() {
            try {
                latch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ",BusiTask begin do work....");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + ",begin do step1 work...");
                    latch.countDown();
                    System.out.println(Thread.currentThread().getName() + ",step1 work is end ...");

                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + ",begin do step2 work...");
                    latch.countDown();
                    System.out.println(Thread.currentThread().getName() + ",step2 work is end ...");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        for(int i = 0;i<3;i++){
            new Thread(new initialTask()).start();
        }
        new Thread(new BusiTask()).start();

        latch.await();
        System.out.println(Thread.currentThread().getName() + ",Main is end");
    }
}

执行结果如下：
在这里插入图片描述

二、CyclicBarrier

1、基本概念及作用

JDK解释：A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point. CyclicBarriers are useful in programs involving a fixed sized party of threads that must occasionally wait for each other. The barrier is called cyclic because it can be re-used after the waiting threads are released.

CyclicBarrier 的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。
CyclicBarrier 默认的构造方法是 CyclicBarrier（int parties），其参数表示屏障拦截的线程数量，每个线程调用 await 方法告诉 CyclicBarrier 我已经到达了屏障，然后当前线程被阻塞。
CyclicBarrier 还提供一个更高级的构造函数 CyclicBarrie（r int parties，Runnable barrierAction），用于在线程到达屏障时，优先执行 barrierAction，方便处理更复杂的业务场景。

2、应用场景

CyclicBarrier 可以用于多线程计算数据，最后合并计算结果的场景。

如下图所示，比如有3个线程Ta、Tb、Tc在执行某业务逻辑，只有当3个线程都到达屏障时，才开始执行后续的逻辑。在这里插入图片描述

3、代码示例

类说明：演示CyclicBarrier用法,共4个子线程，他们全部完成工作后，交出自己结果，再被统一释放去做自己的事情。

package cn.lspj.ch2.tools;

import java.util.concurrent.CyclicBarrier;

/**
 *类说明：演示CyclicBarrier用法,共4个子线程，他们全部完成工作后，交出自己结果，再被统一释放去做自己的事情
 */
public class UseCyclicBarrier {
    private static CyclicBarrier barrier = new CyclicBarrier(4);

    /**
     * 相互等待的子线程
     */
    private static class SubThread implements Runnable{

        @Override
        public void run() {
            try {
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName()+" ....do something ");
                barrier.await(); // 到达屏障，当前线程被阻塞
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName()+" ....do its business ");
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }

    public static void main(String[] args) {
        for(int i=0;i<4;i++){
            Thread thread = new Thread(new SubThread());
            thread.start();
        }
    }
}

执行结果如下：
在这里插入图片描述

类说明：演示CyclicBarrier用法,共4个子线程，他们全部完成工作后，交出自己结果，再被统一释放去做自己的事情，而交出的结果被另外的线程 barrierAction（CollectThread）拿来拼接字符串。如果多次调用CyclicBarrier的await()方法，将对子线程返回结果进行多次汇总。

package cn.lspj.ch2.tools;

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

/**
 * 类说明：演示CyclicBarrier用法,共4个子线程，他们全部完成工作后，交出自己结果，
 * 再被统一释放去做自己的事情，而交出的结果被另外的线程 barrierAction（CollectThread）拿来拼接字符串。
 * 如果多次调用CyclicBarrier的await()方法，将对子线程返回结果进行多次汇总
 */
public class CyclicBarrierToBarrierAction {

    private static CyclicBarrier barrier = new CyclicBarrier(4,new CollectThread());

    // 存放子线程工作结果的容器
    private static Map<String,String> result = new ConcurrentHashMap<>();

    /**
     * 对子线程结果进行汇总的线程
     */
    private static class CollectThread implements Runnable {

        @Override
        public void run() {
            StringBuilder sbResult = new StringBuilder();
            for(Map.Entry entry : result.entrySet()){
                sbResult.append("[" + entry.getValue()+ "] ");
            }
            System.out.println("result=" + sbResult.toString());
            System.out.println("do other something......");
        }
    }

    /**
     * 相互等待的子线程
     */
    private static class SubThred implements Runnable {

        @Override
        public void run() {

            result.put(Thread.currentThread().getName(),"name=" + Thread.currentThread().getName());
            try {
                Thread.sleep(100);
                System.out.println(Thread.currentThread().getName()+",... do something");
                barrier.await();
                Thread.sleep(100);
                System.out.println(Thread.currentThread().getName()+",... do its business");
                barrier.await(); // 如果多次调用CyclicBarrier的await()方法，将对子线程返回结果进行多次汇总
            } catch (InterruptedException e) {
                e.printStackTrace();
            }catch (BrokenBarrierException e) {
                e.printStackTrace();
            }

        }
    }


    public static void main(String[] args) {
        for(int i=0;i<4;i++){
            new Thread(new SubThred()).start();
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}