JUC系列（七）| JUC三大常用工具类CountDownLatch、CyclicBarrier、Semaphore

多线程一直Java开发中的难点，也是面试中的常客，趁着还有时间，打算巩固一下JUC方面知识，我想机会随处可见，但始终都是留给有准备的人的，希望我们都能加油！！！ 沉下去，再浮上来
，我想我们会变的不一样的。

🍟
我们：待别日相见时，都已有所成 。

忽然之间，你忽略的，我忽略的所有细节

当初的猜疑好奇，爱恨痴嗔全已走远

JUC实际辅助类有五个，标题中三个最为常用。剩下未指明的分别为：Phaser、Exchanger。稍后会做简单讲解。

一、🎈CountDownLatch（减计数器）

1）概述：

CountDownLatch位于 java.util.concurrent包下。

CountDownLatch是一个同步辅助类，允许一个或多个线程等待，一直到其他线程执行的操作完成后再执行。

CountDownLatch是通过一个计数器来实现的，计数器的初始值是线程的数量。每当有一个线程执行完毕后，然后通过 countDown 方法来让计数器的值-1，当计数器的值为0时，表示所有线程都执行完毕，然后继续执行 await 方法之后的语句，即在锁上等待的线程就可以恢复工作了。

CountDownLatch中主要有两个方法：

countDown：
- 递减锁存器的计数，如果计数达到零，则释放所有等待的线程。
- 如果当前计数大于零，则递减。如果新计数为零，则为线程调度目的重新启用所有等待线程。
- 如果当前计数为零，则什么也不会发生。
```
public void countDown() {
    sync.releaseShared(1);
}
           
```
await：
- 使当前线程等待直到闩锁倒计时为零，除非线程被中断。
- 如果当前计数为零，则此方法立即返回。即await 方法阻塞的线程会被唤醒，继续执行
- 如果当前计数大于零，则当前线程出于线程调度目的而被禁用并处于休眠状态
```
public void await() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
}

           
```

2）案例：

举个生活中的小例子：

我们一寝室人去上课，得等到1、2、3、4、5、6、7、8个人都出来，才可以锁上寝室门吧。即当计数器值为0时，就可以执行await的方法啦。

编码步骤

：

CountDownLatch countDownLatch = new CountDownLatch(8);
countDownLatch.countDown(); 一个线程出来一个人，计数器就 -1
countDownLatch.await(); 阻塞的等待计数器归零
执行后续步骤

我们用代码来模拟一下这个例子哈：

/**
 * @Author: crush
 * @Date: 2021-08-19 23:21
 * version 1.0
 */
public class CountDownLatchDemo1 {

    public static void main(String[] args) {
        // 初始值8 有八个人需要出寝室门
        CountDownLatch countDownLatch = new CountDownLatch(8);
        for (int i = 1; i <= 8; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "出去啦");
                // 出去一个人计数器就减1
                countDownLatch.countDown();
            }, String.valueOf(i)).start();
        }
        try {
            countDownLatch.await(); // 阻塞等待计数器归零
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 阻塞的操作 ： 计数器  num++
        System.out.println(Thread.currentThread().getName() + "====寝室人都已经出来了，关门向教室冲！！！====");
    }
}

3）小结：

CountDownLatch使用给定的计数进行初始化。由于调用了countDown方法，每次-1， await方法会一直阻塞到当前计数达到零，然后释放所有等待线程，并且任何后续的await调用都会立即返回。这是一种一次性现象——计数无法重置。如果您需要重置计数的版本，请考虑使用

CyclicBarrier

。

CountDownLatch一个有用属性是它不需要调用countDown线程在继续之前等待计数达到零，它只是阻止任何线程通过await,直到所有线程都可以通过。

二、🎀CyclicBarrier（加法计数器）

2.1、概述：

CyclicBarrier 看英文单词就可以看出大概就是循环阻塞的意思。所以还常称为循环栅栏。

CyclicBarrier 主要方法有:

public class CyclicBarrier {

    private int dowait(boolean timed, long nanos); // 供await方法调用 判断是否达到条件 可以往下执行吗
    
    //创建一个新的CyclicBarrier,它将在给定数量的参与方（线程）等待时触发，每执行一次CyclicBarrier就累加1，达到了parties，就会触发barrierAction的执行
    public CyclicBarrier(int parties, Runnable barrierAction) ;
    
    //创建一个新的CyclicBarrier ，参数就是目标障碍数,它将在给定数量的参与方（线程）等待时触发，每次执行 CyclicBarrier 一次障碍数会加一，如果达到了目标障碍数，才会执行 cyclicBarrier.await()之后的语句
    public CyclicBarrier(int parties) 
        
	//返回触发此障碍所需的参与方数量。
    public int getParties()
	
    //等待，直到所有各方都在此屏障上调用了await 。
	// 如果当前线程不是最后一个到达的线程，那么它会出于线程调度目的而被禁用并处于休眠状态.直到所有线程都调用了或者被中断亦或者发生异常中断退出
    public int await()
	
    // 基本同上 多了个等待时间 等待时间内所有线程没有完成，将会抛出一个超时异常
    public int await(long timeout, TimeUnit unit)

    //将障碍重置为其初始状态。 
    public void reset()

}

public CyclicBarrier(int parties)

：的构造方法第一个参数是目标障碍数，每次执行 CyclicBarrier 一次障碍数会加一，如果达到了目标障碍数，才会执行 cyclicBarrier.await()之后的语句。可以将 CyclicBarrier 理解为加 1 操作。

public CyclicBarrier(int parties, Runnable barrierAction)

：的构造方法第一个参数是目标障碍数，每次执行 CyclicBarrier 一次障碍数会加一，如果达到了目标障碍数，就会执行我们传入的Runnable；

2.2、案例：

我想大家多少玩过王者荣耀吧，里面不是有个钻石夺宝吗，抽201次必得荣耀水晶，这次让我们用代码来模拟一下吧。

编程步骤

：

创建CyclicBarrier对象

CyclicBarrier cyclicBarrier = new CyclicBarrier(count, new MyRunnable());
编写业务代码
cyclicBarrier.await(); //在线程里面等待阻塞，累加1,达到最大值count时，触发我们传入进去MyRunnable执行。

/**
 * @Author: crush
 * @Date: 2021-08-20 13:18
 * version 1.0
 */
public class CyclicBarrierDemo1 {

    public static void main(String[] args) {

        // 第一个参数：目标障碍数  第二个参数：一个Runnable任务，当达到目标障碍数时，就会执行我们传入的Runnable
        // 当我们抽了201次的时候，就会执行这个任务。
        CyclicBarrier cyclicBarrier = new CyclicBarrier(201,()->{
            System.out.println("恭喜你，已经抽奖201次，幸运值已满，下次抽奖必中荣耀水晶！！！");
        });

        for (int i=1;i<=201;i++){
            final int count=i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"抽奖一次");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
    }
    // 这行代码是重置计数
    cyclicBarrier.reset();
    
    // 这里是我又加了 一次循环， 可以看到最后结果中输出了两次 "恭喜你"
    for (int i=1;i<=201;i++){
        final int count=i;
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"抽奖一次");
            try {
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        },String.valueOf(i)).start();
    }
}

2.3、小结：

CyclicBarrier和CountDownLatch其实非常相似，CyclicBarrier表示加法，CountDownLatch表示减法。

区别

还是有的：

CyclicBarrier只能够唤醒一个任务，CountDownLatch可以唤起多个任务。
CyclicBarrier可以重置，重新使用，但是CountDownLatch的值等于0时，就不可重复用了。

三、🩰Semaphore（信号灯）

📍、概述：

Semaphore：信号量通常用于限制可以访问某些（物理或逻辑）资源的线程数。

使用场景：

限制资源，如抢位置、限流等。

🎃、案例：

【例子】：

不知道大家有没有过在网吧抢电脑打游戏的那种经历，小时候，平常便宜点的网吧都比较小，而且也比较少，特别多的人去，去晚了的人就只有站在那里看，等别人下机才能上网。

这次的例子就是：网吧有十台高配置打游戏的电脑，有20个小伙伴想要上网。

我们用代码来模拟一下：

编程步骤

：

创建信号灯

Semaphore semaphore = new Semaphore(10); // 5个位置
等待获取信号灯

semaphore.acquire();//等待获取许可证
业务代码
释放信号

semaphore.release();//释放资源,女朋友来找了，下机下机，陪女朋友去了，那么就要释放这台电脑啦

/**
 * @Author: crush
 * @Date: 2021-08-20 14:03
 * version 1.0
 */
public class SemaphoreDemo1 {
    public static void main(String[] args) {
        // 10台电脑
        Semaphore semaphore = new Semaphore(10);

        // 20 个小伙伴想要上网
        for (int i = 1; i <= 20; i++) {
            new Thread(() -> {
                try {
                    //等待获取许可证
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "抢到了电脑");
                    //抢到的小伙伴，迅速就开打啦 这里就模拟个时间哈，
                    TimeUnit.SECONDS.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    //打完几把游戏的小伙伴 女朋友来找了 溜啦溜啦 希望大家都有人陪伴
                    System.out.println("女朋友来找，"+Thread.currentThread().getName() + "离开了");
                    semaphore.release();//释放资源,离开了就要把电脑让给别人啦。
                }
            }, String.valueOf(i)).start();
        }
    }
}

🎠、小结：

在获得一个项目之前，每个线程必须从信号量中获得一个许可，以保证一个项目可供使用。当线程完成该项目时，它会返回到池中，并且将许可返回给信号量，允许另一个线程获取该项目。请注意，调用acquire时不会持有同步锁，因为这会阻止项目返回到池中。信号量封装了限制访问池所需的同步，与维护池本身一致性所需的任何同步分开。
初始化为 1 的信号量，并且使用时最多只有一个许可可用，可以用作互斥锁。这通常被称为二进制信号量，因为它只有两种状态：一种许可可用，或零许可可用。以这种方式使用时，二进制信号量具有属性（与许多java.util.concurrent.locks.Lock实现不同），即“锁”可以由所有者以外的线程释放（因为信号量没有所有权的概念）。这在某些特定上下文中很有用，例如死锁恢复。
此类的构造函数可以选择接受公平参数。当设置为 false 时，此类不保证线程获取许可的顺序。当公平性设置为真时，信号量保证调用任何acquire方法的线程被选择以按照它们对这些方法的调用的处理顺序（先进先出；FIFO）获得许可。
通常，用于控制资源访问的信号量应初始化为公平的，以确保没有线程因访问资源而饿死。当使用信号量进行其他类型的同步控制时，非公平排序的吞吐量优势通常超过公平性考虑。
内存一致性影响：在调用“释放”方法（如release()之前线程中的操作发生在另一个线程中成功的“获取”方法（如acquire()之后的操作之前。

四、🏏简单讲述 | Phaser & Exchanger

4.1、Phaser

Phaser一种可重用的同步屏障，功能上类似于CyclicBarrier和CountDownLatch，但使用上更为灵活。非常适用于在多线程环境下同步协调分阶段计算任务（Fork/Join框架中的子任务之间需同步时，优先使用Phaser）

//默认的构造方法，初始化注册的线程数量为0,可以动态注册
Phaser();
//指定了线程数量的构造方法
Phaser(int parties);
//添加一个注册者  向此移相器添加一个新的未到达方。 如果正在进行对onAdvance调用，则此方法可能会在返回之前等待其完成。
register();
//添加指定数量的注册者  将给定数量的新未到达方添加到此移相器(移相器就是Phaser)。
bulkRegister(int parties);
// 到达屏障点直接执行 无需等待其他人到达。
arrive();
//到达屏障点后，也必须等待其他所有注册者到达这个屏障点才能继续下一步
arriveAndAwaitAdvance();
//到达屏障点，把自己注销了，不用等待其他的注册者到达
arriveAndDeregister();
//多个线程达到注册点之后，会回调这个方法，可以做一些逻辑的补充
onAdvance(int phase, int registeredParties);

package com.crush.juc05;

import java.util.concurrent.Phaser;

public class PhaserDemo {

    private static Phaser phaser = new MyPhaser();

    //自定义一个移相器来自定义输出
    static class MyPhaser extends Phaser {
        /**
         * @deprecated 在即将到来的阶段提前时执行操作并控制终止的可覆盖方法。 此方法在推进此移相器的一方到达时调用（当所有其他等待方处于休眠状态时）。
         *             如果此方法返回true ，则此移相器将在提前时设置为最终终止状态，并且对isTerminated后续调用将返回 true。
         * @param phase 进入此方法的当前阶段号，在此移相器前进之前
         * @param registeredParties 当前注册方的数量
         * @return
         */
        @Override
        protected boolean onAdvance(int phase, int registeredParties) {
            if (phase == 0) {
                System.out.println("所有人都到达了网吧，准备开始开黑！！！");
                return false;
            } else if (phase == 1) {
                System.out.println("大家都同意，一起去次烧烤咯！！！");
                return false;
            } else if (phase == 2) {
                System.out.println("大家一起回寝室！！！");
                return true;
            }
            return true;
        }
    }

    //构建一个线程任务
    static class DoSomeThing implements Runnable {
        @Override
        public void run() {
            /**
             * 向此移相器添加一个新的未到达方
             */
            phaser.register();
            System.out.println(Thread.currentThread().getName() + "从家里出发，准备去学校后街上网开黑！！！");
            phaser.arriveAndAwaitAdvance();
            System.out.println(Thread.currentThread().getName() + "上着上着饿了，说去次烧烤吗？");
            phaser.arriveAndAwaitAdvance();
            System.out.println(Thread.currentThread().getName() + "烧烤次完了");
            phaser.arriveAndAwaitAdvance();
        }
    }

    public static void main(String[] args) throws Exception {
        DoSomeThing thing = new DoSomeThing();
        new Thread(thing, "小明").start();
        new Thread(thing, "小王").start();
        new Thread(thing, "小李").start();
    }
}
/**
 * 小李从家里出发，准备去学校后街上网开黑！！！
 * 小王从家里出发，准备去学校后街上网开黑！！！
 * 小明从家里出发，准备去学校后街上网开黑！！！
 * 所有人都到达了网吧，准备开始开黑！！！
 * 小李上着上着饿了，说去次烧烤吗？
 * 小明上着上着饿了，说去次烧烤吗？
 * 小王上着上着饿了，说去次烧烤吗？
 * 大家都同意，一起去次烧烤咯！！！
 * 小明烧烤次完了
 * 小李烧烤次完了
 * 小王烧烤次完了
 * 大家一起回寝室！！！
 */

注意

：这里只是做了简单的一个使用，更深入的了解，我暂时也没有，想要研究可以去查一查。

4.2、Exchanger

Exchanger允许两个线程在某个汇合点交换对象，在某些管道设计时比较有用。

Exchanger提供了一个同步点，在这个同步点，一对线程可以交换数据。每个线程通过exchange()方法的入口提供数据给他的伙伴线程，并接收他的伙伴线程提供的数据并返回。

当两个线程通过Exchanger交换了对象，这个交换对于两个线程来说都是安全的。Exchanger可以认为是 SynchronousQueue 的双向形式，在运用到遗传算法和管道设计的应用中比较有用。

这个的使用我在Dubbo中的总体架构图中看到了它的身影。

JUC系列（七）| JUC三大常用工具类CountDownLatch、CyclicBarrier、Semaphore

五、🎡自言自语

最近又开始了JUC的学习，感觉Java内容真的很多，但是为了能够走的更远，还是觉得应该需要打牢一下基础。

最近在持续更新中，如果你觉得对你有所帮助，也感兴趣的话，关注我吧，让我们一起学习，一起讨论吧。

你好，我是博主

宁在春

，Java学习路上的一颗小小的种子，也希望有一天能扎根长成苍天大树。

希望

与君共勉

😁

待我们，别时相见时，都已有所成。

希望再遇见

参考：JUC并发编程（八）-JUC常用辅助类

JUC系列（七）| JUC三大常用工具类CountDownLatch、CyclicBarrier、Semaphore

一、🎈CountDownLatch（减计数器）

1）概述：

2）案例：

3）小结：

二、🎀CyclicBarrier（加法计数器）

2.1、概述：

2.2、案例：

2.3、小结：

三、🩰Semaphore（信号灯）

📍、概述：

🎃、案例：

🎠、小结：

四、🏏简单讲述 | Phaser & Exchanger

4.1、Phaser

4.2、Exchanger

五、🎡自言自语

继续阅读

关于Gradle配置的小结

Java小案例——随机数猜测随机数猜测

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method

JUC系列（七）| JUC三大常用工具类CountDownLatch、CyclicBarrier、Semaphore

一、🎈CountDownLatch（减计数器）

1）概述：

2）案例：

3）小结：

二、🎀CyclicBarrier（加法计数器）

2.1、概述：

2.2、案例：

2.3、小结：

三、🩰Semaphore（ 信号灯）

📍、概述：

🎃、案例：

🎠、小结：

四、🏏简单讲述 | Phaser & Exchanger

4.1、Phaser

4.2、Exchanger

五、🎡自言自语

继续阅读

三、🩰Semaphore（信号灯）