juc包下的四大工具类

最新推荐文章于 2025-04-08 07:00:00 发布
最新推荐文章于 2025-04-08 07:00:00 发布
阅读量1.3k 收藏 5
点赞数 1
分类专栏： 学习总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_42617262/article/details/90436798
版权
本文详细介绍了Java并发编程中juc包的四大工具类：CountDownLatch、CyclicBarrier、Exchanger和Semaphore。CountDownLatch用于线程等待其他线程完成任务；CyclicBarrier可以重复使用，允许线程在特定条件达成后继续执行；Exchanger用于两个线程间的数据交换；Semaphore则作为信号量，限制同时访问特定资源的线程数量。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

juc包下的四大工具类

CountDownLatch

CyclicBarrier

Exchange

Semaphore

1.CountDownLatch–闭锁

作用为：解决一个线程需等待其他线程完成任务后再次恢复执行的情景。

注意：每个CountDownLatch对象的计数器在减为0时不可恢复原值。

CountDownLatch类常用方法：

//调用await()方法的线程阻塞直到其他线程完成任务才可恢复执行
1.public void await() throws InterruptedException {}
//await()方法的重载方法，作用为等待timeout时间后无论其他线程是否完成任务均恢复执行
2.public boolean await(long timeout, TimeUnit unit) throws InterruptedException {}
//CountDownLatch类唯一的构造方法，count为需要等待完成任务线程数量
3.public CountDownLatch(int count) {}
//该方法为兵法执行任务的线程调用，调用countDown方法相当于已执行完任务，count--，直到count=0时最初调用await()方法的阻塞线程才可恢复执行
4.public void countDown() {}

假想一个这样的场景：运动场上，裁判一声哨响，运动员起跑，裁判开始计时，等待最后一位运动员到达终点时裁判才可按下计时器，结束比赛。那么也就是说裁判要等到所有运动员都到达终点后才可按下计时器。那这个场景我们要怎么实现呢？使用之前多线程部分的知识，我们很容易就能想到join()方法，假想裁判是主线程，运动员均是子线程，使用join()方法就需要在所有子线程在主线程中调用join()方法，但线程在调用join()方法的先后顺序上也可能影响运行结果。

针对以上场景，我们可用CountDownLatch完美解决：

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

class CountDownLatchTest implements Runnable{
    private CountDownLatch countDownLatch;
    public CountDownLatchTest(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"到达终点");
        countDownLatch.countDown();
    }
}
public class ThreadTest{
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch=new CountDownLatch(3);
        System.out.println("比赛开始...");
        new Thread(new CountDownLatchTest(countDownLatch),"运动员A").start();
        TimeUnit.SECONDS.sleep(2);
        new Thread(new CountDownLatchTest(countDownLatch),"运动员B").start();
        TimeUnit.SECONDS.sleep(2);
        new Thread(new CountDownLatchTest(countDownLatch),"运动员C").start();
        countDownLatch.await();
        System.out.println("所有运动员均到达终点，比赛结束！");
    }
}

/*
比赛开始...
运动员A到达终点
运动员B到达终点
运动员C到达终点
所有运动员均到达终点，比赛结束！
*/

CountDownLatch图示：

在这里插入图片描述

2.CyclicBarrier–循环栅栏
注意：每个CyclicBarrier对象可重复使用。

CyclicBarrier常用方法：

//parties为需阻塞子线程个数
1.public CyclicBarrier(int parties) {}
//parties为需阻塞子线程个数，barrierAction为等所有线程到达同步点后，随机唤醒一个线程执行barrierAction任务，之后再全部线程恢复执行
2.public CyclicBarrier(int parties, Runnable barrierAction) {}
//子线程调用await()方法阻塞当前线程，CyclicBarrier计数器减一，直到减为0后恢复执行
3.public int await() throws InterruptedException, BrokenBarrierException {}

假想这样场景：有一本书，三个人分模块同时书写，假设A先写完，此时书不可能直接出版，必须等到剩余两人都写完才可以出版。下面用代码实现此场景：

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

class CycliBarrierTest implements Runnable{
    private CyclicBarrier cyclicBarrier;

    public CycliBarrierTest(CyclicBarrier cyclicBarrier) {
        this.cyclicBarrier = cyclicBarrier;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"已到达栅栏");
        try {
            cyclicBarrier.await();
            System.out.println(Thread.currentThread().getName()+"已完成任务");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
    }
}
public class ThreadTest{
    public static void main(String[] args) throws InterruptedException {
        CyclicBarrier cyclicBarrier=new CyclicBarrier(3);
        for(int i=0;i<3;i++){
            new Thread(new CycliBarrierTest(cyclicBarrier),"线程"+(i+1)).start();
            TimeUnit.SECONDS.sleep(2);
        }
    }
}
/**
线程1已到达栅栏
线程2已到达栅栏
线程3已到达栅栏
线程3已完成任务
线程1已完成任务
线程2已完成任务
**/

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

class CycliBarrierTest implements Runnable{
    private CyclicBarrier cyclicBarrier;

    public CycliBarrierTest(CyclicBarrier cyclicBarrier) {
        this.cyclicBarrier = cyclicBarrier;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"已到达栅栏");
        try {
            cyclicBarrier.await();
            System.out.println(Thread.currentThread().getName()+"已完成任务");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
    }
}
public class ThreadTest{
    public static void main(String[] args) throws InterruptedException {
        CyclicBarrier cyclicBarrier=new CyclicBarrier(3, new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行barrierAction任务");
            }
        });
        for(int i=0;i<3;i++){
            new Thread(new CycliBarrierTest(cyclicBarrier),"线程"+(i+1)).start();
            TimeUnit.SECONDS.sleep(2);
        }
    }
}
/**
线程1已到达栅栏
线程2已到达栅栏
线程3已到达栅栏
线程3执行barrierAction任务
线程1已完成任务
线程2已完成任务
线程3已完成任务
**/

CyclicBarrier图示：

在这里插入图片描述

3.Exchanger—线程数据交换器
应用场景：用于两个线程交换数据(不能用于多个)

常用方法：

public V exchange(V x) throws InterruptedException {}//调用exchange()方法会阻塞当前线程，必须等到另外一个线程时才可进行数据交换

Exchanger简单实现：

import java.util.concurrent.Exchanger;

public class ThreadTest{
    public static void main(String[] args) {
        Exchanger<String> exchanger=new Exchanger<>();
        Thread girl=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    String str=exchanger.exchange("我喜欢你！");
                    System.out.println("女孩说："+str);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        girl.start();
        Thread boy=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    String str=exchanger.exchange("我也是！");
                    System.out.println("男孩说："+str);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        boy.start();
    }
}
/**
男孩说：我喜欢你！
女孩说：我也是！
**/

Exchange图示：

在这里插入图片描述

4.Semaphore—信号量

常用方法：

//调用acquire()方法默认为申请一个信号量
1.public void acquire() throws InterruptedException {}
//permits为申请信号量数
2.public void acquire(int permits) throws InterruptedException {}
//默认释放一个信号量
3.public void release() {}
//释放permits个信号量
4.public void release(int permits) {}

假想一个这样的场景：一个工厂有8个工人5台机器，每台机器最多只能一个人进行操作，因此最多5人工作。

以下为Semaphore实现以上情景：

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

class SemaphoreTest implements Runnable{
    private Semaphore semaphore;
    private Integer num;

    public SemaphoreTest(Semaphore semaphore, Integer num) {
        this.semaphore = semaphore;
        this.num = num;
    }

    @Override
    public void run() {
        try {
            semaphore.acquire();
            System.out.println("工人"+this.num+"占用一台设备");
            TimeUnit.SECONDS.sleep(2);
            System.out.println("工人"+this.num+"释放本设备");
            semaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class ThreadTest{
    public static void main(String[] args) {
        Semaphore semaphore=new Semaphore(5);
        //8个工人，5台机器
        for(int i=0;i<8;i++){
            new Thread(new SemaphoreTest(semaphore,i+1)).start();
        }
    }
}

/**
工人1占用一台设备
工人2占用一台设备
工人3占用一台设备
工人4占用一台设备
工人5占用一台设备
工人2释放本设备
工人4释放本设备
工人5释放本设备
工人3释放本设备
工人8占用一台设备
工人1释放本设备
工人7占用一台设备
工人6占用一台设备
工人8释放本设备
工人7释放本设备
工人6释放本设备
**/


import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

class SemaphoreTest implements Runnable{
    private Semaphore semaphore;
    private Integer num;

    public SemaphoreTest(Semaphore semaphore, Integer num) {
        this.semaphore = semaphore;
        this.num = num;
    }

    @Override
    public void run() {
        try {
            semaphore.acquire(2);
            System.out.println("工人"+this.num+"占用一台设备");
            TimeUnit.SECONDS.sleep(2);
            System.out.println("工人"+this.num+"释放本设备");
            semaphore.release(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class ThreadTest{
    public static void main(String[] args) {
        Semaphore semaphore=new Semaphore(5);
        //8个工人，5台机器
        for(int i=0;i<8;i++){
            new Thread(new SemaphoreTest(semaphore,i+1)).start();
        }
    }
}
/**
工人2占用一台设备
工人3占用一台设备
工人2释放本设备
工人4占用一台设备
工人3释放本设备
工人1占用一台设备
工人1释放本设备
工人4释放本设备
工人5占用一台设备
工人6占用一台设备
工人6释放本设备
工人5释放本设备
工人7占用一台设备
工人8占用一台设备
工人8释放本设备
工人7释放本设备
**/

Semaphore图示：

在这里插入图片描述

JUC同步工具类——信号量、闭锁、栅栏、交换器
jiangqiongfeng的博客
03-06 1398
同步工具类可以使任何一种对象，只要该对象可以根据自身的状态来协调控制线程的控制流。阻塞队列可以作为同步工具类，其他类型的同步工具类还包括：信号量（Semaphore）、栅栏（Barrier）、闭锁（Latch）以及交换器（Exchanger）。 –《Java并发编程实战》
高并发JUC详解
weixin_48958124的博客
08-26 2180
多线程进阶之高并发编程
JUC工具类
weixin_44199948的博客
07-27 370
什么是JUC java.util工具包 并发：多线程操作同一个资源 并行：多个线程同时执行 public static void main(String[] args) { // 获取cpu的核数 //CPU密集型 IO密集型 System.out.println(Runtime.getRuntime().availableProcessors()); } 并发编程的本质：充分利用CPU的资源 线程有几种状态 NEW,//创建 RUNNABL.
【多线程】JUC包下的常见类
最新发布
我的博客
04-08 936
介绍java.util.concurrent包下的常用类
常用的JUC（Java Util Concurrent）工具类
weixin_44440231的博客
04-14 2323
包下的原子类为Java并发编程提供了一组高效的、线程安全的原子操作类，它们主要用于在高并发环境下确保对共享变量的操作具有原子性，即在同一时刻只有一个线程能够修改这些变量的值，而不会出现因多线程并发导致的中间状态或数据竞争问题。当两个线程都到达交换点时，它们各自携带的数据会被互换，确保线程间的通信和协作。，等待其他线程也到达屏障。当所有线程都到达后，屏障动作执行，然后屏障重置，线程们继续进行下一次迭代，如此反复三次。的特性，它们各自操作的是独立的本地副本，因此输出结果互不影响，展示了线程间数据的隔离。
juc工具类
sunleiLoveCode的博客
08-21 222
/** * 描述： 利用ThreadLocal，给每个线程分配自己的dateFormat对象，保证了线程安全，高效利用内存 */ public class ThreadLocalNormalUsage05 { public static ExecutorService threadPool = Executors.newFixedThreadPool(10); public static void main(String[] args) throws InterruptedE...
JUC并发编程入门学习笔记（狂神说）
Free的午后
08-06 1343
因为热爱所以坚持，因为热爱所以等待。熬过漫长无戏可演的日子，终于换来了人生的春天，共勉！！！ 1. 什么是JUC JUC就是java.util.concurrent下面的类包，专门用于多线程的开发。 2. 线程和进程 进程是操作系统中的应用程序、是资源分配的基本单位，线程是用来执行具体的任务和功能，是CPU调度和分派的最小单位 一个进程往往可以包含多个线程，至少包含一个 1）进程 一个程序，QQ.EXE Music.EXE；数据+代码+pcb 一个进程可以包含多个线程，至少包含一个线..
JUC详解
热门推荐
weixin_42998267的博客
04-07 1万+
1.什么是JUC(面试高频) java.util工具包、包、分类 业务：普通的线程代码 Thread Runnable 没有返回值、效率相比于Callable相对较低 2.线程和进程 进程：一个程序，QQ.exe Music.exe 程序的集合； 一个进程往往可以包含多个线程，至少包含一个！ java默认有几个线程？2个线程 main线程、GC线程 线程：开了一个进程Typora，写字，自动...
JUC进阶
qq_44787933的博客
08-01 190
java.util工具包，包，分类Runnable 没有返回值、效率相比于Callable相对比较低进程：一个程序（QQ.exe Music.exe） 的集合一个进程往往可以包含多个线程，至少包含一个！java默认有几个线程？ 2个 main、GC线程：开了一个oneNote，写字，自动保存（线程负责）对于Java而言：Thread、Runnable、Callable 并发编程：并发、并行并发（多线程操作同一个资源）并行（多个人一起行走） 并发编程的本质：充分利用CPU的资源 1.来自不同的类wait
JUC重点详解
qq_41307492的博客
01-26 1048
一、前瞻 1、什么是JUC java.util.concurrent包 2、线程与进程 一个进程往往包含多个线程 java默认有两个线程：main、GC(垃圾回收) java真的可以开启线程吗？ 不可以，底层使用C++，java无法直接操作硬件 1>线程六大状态 //新生 NEW, //运行 RUNNABLE, //阻塞 BLOCKED, //等待 WAITING,
JUC常见工具类
qq_40025976的博客
08-19 1052
JUC常见工具类
JUC常用工具类
有点想法的专栏
04-04 2817
文章目录1.JUC1.1 CountDownLatch1.1.1 介绍1.1.2 举例1.1.3 注意1.2 CyclicBarrier1.2.1 介绍1.2.2 举例1.2.3 注意1.3 Semaphore1.3.1 介绍1.3.2 举例1.3.3 注意1.4 Exchanger1.4.1 介绍1.4.2 举例参考 1.JUC JUC就是java.util .concurrent工具包的简称。...
JUC工具包介绍
11-14 995
JUC工具包，全称为Java.util.concurrent工具包，是Java提供的用于实现多线程编程的工具集合。它是在Java 5版本中引入的，并在后续版本中得到了进一步的扩展和优化。JUC工具包中包含了许多常用的组件和类，如线程池（Executor）、并发集合类（Concurrent Collections）、原子类（Atomic）、锁（Lock）、同步器（Synchronizers）等。这些组件和类提供了一些高效、可扩展和线程安全的机制，可以帮助开发者更好地处理并发访问、线程同步和协作等问题。
JUC常见工具类（笔记）
lxh123456789asd的博客
09-06 309
Condition Condition是一个多线程协调通信的工具类，可以让某些线程一起等待某个条件（condition），只有满足条件时，线程才会被唤醒。Condtion在lock.lock（）以及Lock.unlock（）方法体里面。 Condition主要方法：condition.await()、condition.signal()、condition.signalAll();。 Condtion调用await()方法后会释放锁。 CountDownLatch countDownLatch是一个同步
JUC工具类的使用
BingzangAiyuzi的博客
06-11 365
JUC工具类的使用 简介 JUC指的是java.util.concurrent包下的工具类的简称，在jdk1.5时开始出现。 常用工具类 CountdownLatch CyclicBarrier Semaphore Exchanger 3.工具类的使用 CountdownLatch CountdownLatch的构造方法初始化时会给定一个固定的计数值大小，之后每次调用对象的countdown方法后该值都会减一，当这个值不是0的话，调用对象的await方法会一直阻塞下面的方法，直到为0。 使
JUC——线程同步辅助工具类（Semaphore，CountDownLatch，CyclicBarrier）
Java铭的博客
10-08 397
CountDownLatch CountDownLatch是一个计数器闭锁，通过它可以完成类似于阻塞当前线程的功能，即：一个线程或多个线程一直等待，直到其他线程执行的操作完成。CountDownLatch用一个给定的计数器来初始化，该计数器的操作是原子操作，即同时只能有一个线程去操作该计数器。调用该类await方法的线程会一直处于阻塞状态，直到其他线程调用countDown方法使当前计数器的值变为...
死磕Java多线程（十一）JUC常用工具类的简单介绍和使用
盐二白
08-31 536
1. CountDownLatch 在日常开发中经常会遇到需要在主线程中开启多个线程去并行执行任务，并且主线程需要等待所有子线程执行完毕后再进行汇总的场景。在CountDownLatch出现之前一般都使用线程的join（）方法来实现这一点，但是join方法不够灵活，不能够满足不同场景的需要，所以JDK开发组提供了CountDownLatch这个类能够使一个线程等待其他线程完成各自的工作后再执行。例...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值