java并发编程2.2并发工具类——CountDownLatch和CyclicBarrier使用及比较

最新推荐文章于 2022-03-15 17:47:21 发布

叶落自飘零

最新推荐文章于 2022-03-15 17:47:21 发布

阅读量675

点赞数

分类专栏：高并发编程 java并发编程文章标签： CountDownLatch CyclicBarrie CountDownLatch和CyclicBarrie的比较并发工具类

本文链接：https://blog.csdn.net/u010904188/article/details/86747752

版权

高并发编程同时被 2 个专栏收录

11 篇文章 1 订阅

订阅专栏

java并发编程

10 篇文章 1 订阅

订阅专栏

环境：

jdk1.8

摘要说明：

上一章节主要讲述如何按照fork-join范式如何将大任务划分成多个小任务分而治之；

从本章节主要讲述两个工具类CountDownLatch和CyclicBarrier使用及比较；

CountDownLatch：一种同步辅助工具，允许一个或多个线程等待，直到在其他线程中执行的一组操作完成；CountDownLatch使用给定的计数初始化。wait方法阻塞，直到当前计数由于countDown()方法的调用而达到零，在此之后释放所有等待的线程，并立即返回任何后续的wait调用。这是一个一次性现象——计数无法重置。

CyclicBarrier：一种同步辅助工具，它允许一组线程相互等待到达共同的屏障点。循环屏障在涉及固定大小的线程组的程序中非常有用，这些线程组偶尔必须相互等待。这个屏障被称为循环的，因为它可以在等待的线程释放后被重用。

步骤：

1.CountDownLatch的基础用法

CountDownLatch：一种同步辅助工具，允许一个或多个线程等待，直到在其他线程中执行的一组操作完成；

CountDownLatch使用给定的计数初始化。wait方法阻塞，直到当前计数由于countDown()方法的调用而达到零，在此之后释放所有等待的线程，并立即返回任何后续的wait调用。这是一个一次性现象——计数无法重置。如果您需要一个可以重置计数的版本，可以考虑使用cycle barrier。

CountDownLatch是一种通用的同步工具，可以用于多种目的。其中经典的两种使用方式有：

方式一：用一个count初始化的CountDownLatch用作简单的开/关锁或门:所有想打开该门的线程都在等待，直到CountDownLatch被调用countDown()方法count次为零，所有线程释放进入门做各自业务；
方式二：初始化为N的CountDownLatch可以让一个线程等待，直到N个线程完成某个操作，或者某个操作已经完成N次。

方式一实践：

由于这种方式很贴近运动员赛跑，需等待所有运动员准备完成之后才统一起跑，所以这种方式CountDownLatch也被称作发令枪；这个调用方式也常用于模拟高并发，大家可以参考之前的文章高并发编程之高并发场景：秒杀（无锁、排他锁、乐观锁、redis缓存的逐步演变）

package pers.cc.curriculum2.countDownLatch;

import java.util.concurrent.CountDownLatch;

/**
 * CountDownLatch测试类：10个运动员一一准备，等都准备好统一听发令枪一起起跑
 * 
 * 
 * @author cc
 *
 */
public class CountDownLatchAwaitN {
    // 定义一个总数为14的计数器
    static CountDownLatch latch = new CountDownLatch(14);

    private static class InitThread implements Runnable {
        private String name;

        public InitThread(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            System.out.println(name + "已准备好！");
            // 初始化线程完成工作了，调用countDown方法扣减一次；
            latch.countDown();
            try {
                // 堵塞所有子进程等候计数器号令
                latch.await();
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(name + "启动：" + System.currentTimeMillis());

        }

    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 1; i <= 10; i++) {
            Thread thread = new Thread(new InitThread("运动员" + i));
            thread.start();
        }
        Thread.sleep(1000);
        System.out.println("3");
        latch.countDown();
        System.out.println("2");
        latch.countDown();
        System.out.println("1");
        latch.countDown();
        System.out.println("啪");
        latch.countDown();
    }
}

运行结果如下，可以看到子线程被await方法堵塞，知道计算器减到0统一启动：

运动员1已准备好！
运动员2已准备好！
运动员6已准备好！
运动员10已准备好！
运动员3已准备好！
运动员4已准备好！
运动员7已准备好！
运动员5已准备好！
运动员8已准备好！
运动员9已准备好！
3
2
1
啪
运动员1启动：1549087623847
运动员6启动：1549087623847
运动员4启动：1549087623847
运动员2启动：1549087623847
运动员3启动：1549087623847
运动员9启动：1549087623847
运动员10启动：1549087623847
运动员8启动：1549087623847
运动员5启动：1549087623847
运动员7启动：1549087623847

方式二实践：

方式二就类似我们需要装货出发一样；n个人同时搬货，只有当我们车上装满了指定个数count个货物，才可以进行配送；

package pers.cc.curriculum2.countDownLatch;

import java.util.concurrent.CountDownLatch;

import pers.cc.tools.SleepTools;

/**
 * CountDownLatch测试类：装满指定个数货物才能进行配送
 * 
 * 
 * @author cc
 *
 */
public class CountDownLatchAwaitOne {
    // 定义一个总数为30的计数器
    static CountDownLatch latch = new CountDownLatch(30);

    private static class InitThread implements Runnable {

        @Override
        public void run() {
            // 每个人装3个货物
            for (int i = 1; i <= 3; i++) {
                SleepTools.ms(200);
                System.out.println("Thread_" + Thread.currentThread().getId()
                        + "已准备好一个货物！");
                // 初始化线程完成工作了，调用countDown方法扣减一次；
                latch.countDown();
            }
        }

    }

    public static void main(String[] args) throws InterruptedException {
        // 10个人装，每个人装3个货物
        for (int i = 1; i <= 10; i++) {
            Thread thread = new Thread(new InitThread());
            thread.start();
        }
        latch.await();
        System.out.println("货物装好出发");
    }
}

上述的演示结果如下：

Thread_15已准备好一个货物！
.......
Thread_19已准备好一个货物！
货物装好出发

总结：

构造方法：

CountDownLatch(int count)：构造使用给定的计数初始化的CountDownLatch。

常用方法：

void await()：使当前线程等待，直到计数器计数到零，除非线程被中断。
boolean await(long timeout, TimeUnit unit) :使当前线程等待，直到锁存器计数到零，除非线程被中断，或指定的等待时间已经过。
void countDown():减少计数器的计数，如果计数为零，释放所有等待的线程。
long getCount()：返回当前计数

2.CyclicBarrier的基础用法

cycles barrier支持一个可选的Runnable命令，该命令在参与方的最后一个线程到达之后，但在任何线程被释放之前，在每个屏障点上运行一次。此屏障操作对于在任何缔约方继续之前更新共享状态非常有用。

cycles barrier适用的场景：

场景一：就是指定线程都进入指定等待状态后；统一进行后续的动作；

场景二：就是指定线程都进入指定等待状态后；先进行指定Runnable的操作后，再统一进行后续的动作；

package pers.cc.curriculum2.cyclesBarrier;

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

import pers.cc.tools.SleepTools;

/**
 * CyclesBarrier:一组线程相互等待到达共同的屏障点,可选择先执行一个Runnable操作，也可立即进行线程的后续操作
 * 
 * @author cc
 *
 */
public class CyclesBarrierTest {
    // 场景1：定义一组线程相互等待后立即执行后续
    private static CyclicBarrier barrier1 = new CyclicBarrier(5);

    // 场景2：定义一组线程相互等待后先执行CollectThread线程再执行各自后续
    private static CyclicBarrier barrier2 = new CyclicBarrier(5,
            new CollectThread());

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

    /**
     * 场景1初始线程
     * 
     * @author cc
     *
     */
    private static class InitThread1 implements Runnable {
        @Override
        public void run() {
            long id = Thread.currentThread().getId();
            try {
                Thread.sleep(200 + id);
                System.out.println(id + "....is await");
                barrier1.await();
                System.out.println("Thread_" + id + " ....do its business ");
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
            catch (BrokenBarrierException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

    /**
     * 场景2初始线程
     * 
     * @author cc
     *
     */
    private static class InitThread2 implements Runnable {

        @Override
        public void run() {
            long id = Thread.currentThread().getId();
            // 线程本身的处理结果
            resultMap.put(Thread.currentThread().getId() + "", id);
            // 随机决定工作线程的是否睡眠
            Random r = new Random();
            try {
                if (r.nextBoolean()) {
                    Thread.sleep(2000 + id);
                }
                System.out.println(id + "....is await");
                barrier2.await();
                System.out.println("Thread_" + id + " ....do its business ");
            }
            catch (Exception e) {
                e.printStackTrace();
            }

        }
    }

    // 负责屏障开放以后的工作
    private static class CollectThread implements Runnable {

        @Override
        public void run() {
            StringBuilder result = new StringBuilder();
            for (Map.Entry < String, Long > workResult : resultMap.entrySet()) {
                result.append("[" + workResult.getValue() + "]");
            }
            System.out.println(" the result = " + result);
            System.out.println("do other business........");
        }
    }

    public static void main(String[] args) {
        System.out
                .println("——————————————————————场景1——————————————————————————");
        for (int i = 0; i < 5; i++) {
            new Thread(new InitThread1()).start();
        }
        // 休眠两秒
        SleepTools.second(2);
        System.out
                .println("——————————————————————场景2——————————————————————————");
        for (int i = 0; i < 5; i++) {
            new Thread(new InitThread2()).start();
        }
    }
}

运行结果如下：

——————————————————————场景1——————————————————————————
10....is await
11....is await
12....is await
13....is await
14....is await
Thread_10 ....do its business 
Thread_11 ....do its business 
Thread_12 ....do its business 
Thread_13 ....do its business 
Thread_14 ....do its business 
——————————————————————场景2——————————————————————————
16....is await
17....is await
15....is await
18....is await
19....is await
 the result = [15][16][17][18][19]
do other business........
Thread_19 ....do its business 
Thread_16 ....do its business 
Thread_18 ....do its business 
Thread_15 ....do its business 
Thread_17 ....do its business

总结：

构造方法：

CyclicBarrier(int parties)：创建一个新的cycle barrier，当给定数量的参与方(线程)等待它时，它将跳闸即消除屏障，当跳闸时，它不会执行预定义的操作。

CyclicBarrier(int parties, Runnable barrierAction):创建一个新的cycle barrier，当给定数量的参与方(线程)等待它时，它将跳闸即消除屏障，当跳闸时，它会进入执行的barrierAction线程先执行预定操作；

常用方法：

void await()：使当前线程等待，直到计数器计数到零，除非线程被中断。
boolean await(long timeout, TimeUnit unit) :使当前线程等待，直到锁存器计数到零，除非线程被中断，或指定的等待时间已经过。
void getNumberWaiting():返回当前在屏障处等待的参与方的数量。
long getParties()：返回访问此屏障所需的参与方的数量。
boolean isBroken()：查询此屏障是否处于破坏状态。
void reset()：将屏障重置为初始状态。

3.CountDownLatch和CyclicBarrie的比较

从复用性上来说，CountDownLatch是一次性的，CyclicBarrie是可复用的；

从阻塞线程数量上来说：CyclicBarrie必须阻塞所有子线程；CountDownLatch更加自由，可只阻塞一个主线程，也可阻塞所有子线程；

从根本思路上说：CountDownLatch只是一个计数器，当计数器计数为0时，受他堵塞的线程得到释放；而CyclicBarrie是一组线程间的相互等待，它的堵塞想要得到释放必须要所有参于线程都到达指定屏障；

4.源码地址

https://github.com/cc6688211/concurrent-study.git

叶落自飘零

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java并发编程2.2并发工具类——CountDownLatch和CyclicBarrier使用及比较

从本章节主要讲述两个工具类CountDownLatch和CyclicBarrier使用及比较；CountDownLatch：一种同步辅助工具，允许一个或多个线程等待，直到在其他线程中执行的一组操作完成；CyclicBarrier：一种同步辅助工具，它允许一组线程相互等待到达共同的屏障点
复制链接

扫一扫