JUC 笔记 9

于 2024-06-06 09:42:06 发布
阅读量238 收藏 5
点赞数 2
分类专栏： juc 文章标签： 笔记 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gkqstd/article/details/139486374
版权

1. CountdownLatch

用来进行线程同步协作，等待所有线程完成倒计时。
其中构造参数用来初始化等待计数值，await() 用来等待计数归零，countDown() 用来让计数减一

示例1

public static void main(String[] args) throws InterruptedException {
    CountDownLatch latch = new CountDownLatch(3);
    
    new Thread(() -> {
        log.debug("begin...");
        sleep(1);
        latch.countDown();
        log.debug("end...{}", latch.getCount());
    }).start();
    
    new Thread(() -> {
        log.debug("begin...");
        sleep(2);
        latch.countDown();
        log.debug("end...{}", latch.getCount());
    }).start();
    
    new Thread(() -> {
        log.debug("begin...");
        sleep(1.5);
        latch.countDown();
        log.debug("end...{}", latch.getCount());
    }).start();
    
    log.debug("waiting...");
    latch.await();
    log.debug("wait end...");
}

结果

18:44:00.778 c.TestCountDownLatch [main] - waiting... 
18:44:00.778 c.TestCountDownLatch [Thread-2] - begin... 
18:44:00.778 c.TestCountDownLatch [Thread-0] - begin... 
18:44:00.778 c.TestCountDownLatch [Thread-1] - begin... 
18:44:01.782 c.TestCountDownLatch [Thread-0] - end...2 
18:44:02.283 c.TestCountDownLatch [Thread-2] - end...1 
18:44:02.782 c.TestCountDownLatch [Thread-1] - end...0 
18:44:02.782 c.TestCountDownLatch [main] - wait end...

可以配合线程池使用，改进如下

public static void main(String[] args) throws InterruptedException {
    CountDownLatch latch = new CountDownLatch(3);
    ExecutorService service = Executors.newFixedThreadPool(4);
    
    service.submit(() -> {
        log.debug("begin...");
        sleep(1);
        latch.countDown();
        log.debug("end...{}", latch.getCount());
    });
    
    service.submit(() -> {
        log.debug("begin...");
        sleep(1.5);
        latch.countDown();
        log.debug("end...{}", latch.getCount());
    });
    
    service.submit(() -> {
        log.debug("begin...");
        sleep(2);
        latch.countDown();
        log.debug("end...{}", latch.getCount());
    });
    
    service.submit(()->{
        try {
            log.debug("waiting...");
            latch.await();
            log.debug("wait end...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
    
}

输出

18:52:25.831 c.TestCountDownLatch [pool-1-thread-3] - begin... 
18:52:25.831 c.TestCountDownLatch [pool-1-thread-1] - begin... 
18:52:25.831 c.TestCountDownLatch [pool-1-thread-2] - begin... 
18:52:25.831 c.TestCountDownLatch [pool-1-thread-4] - waiting... 
18:52:26.835 c.TestCountDownLatch [pool-1-thread-1] - end...2 
18:52:27.335 c.TestCountDownLatch [pool-1-thread-2] - end...1 
18:52:27.835 c.TestCountDownLatch [pool-1-thread-3] - end...0 
18:52:27.835 c.TestCountDownLatch [pool-1-thread-4] - wait end...

* 应用之同步等待多线程准备完毕

AtomicInteger num = new AtomicInteger(0);

ExecutorService service = Executors.newFixedThreadPool(10, (r) -> {
    return new Thread(r, "t" + num.getAndIncrement());
});

CountDownLatch latch = new CountDownLatch(10);

String[] all = new String[10];
Random r = new Random();
for (int j = 0; j < 10; j++) {
    int x = j;
    service.submit(() -> {
        for (int i = 0; i <= 100; i++) {
            try {
                Thread.sleep(r.nextInt(100));
            } catch (InterruptedException e) {
            }
            all[x] = Thread.currentThread().getName() + "(" + (i + "%") + ")";
            System.out.print("\r" + Arrays.toString(all));
        }
        latch.countDown();
    });
}

latch.await();
System.out.println("\n游戏开始...");
service.shutdown();

结果

//中间输出
[t0(52%), t1(47%), t2(51%), t3(40%), t4(49%), t5(44%), t6(49%), t7(52%), t8(46%), t9(46%)] 
//最后输出
[t0(100%), t1(100%), t2(100%), t3(100%), t4(100%), t5(100%), t6(100%), t7(100%), t8(100%), t9(100%)] 
游戏开始...

* 应用之同步等待多个远程调用结束

@RestController
public class TestCountDownlatchController {
    @GetMapping("/order/{id}")
    public Map<String, Object> order(@PathVariable int id) {
        HashMap<String, Object> map = new HashMap<>();
        map.put("id", id);
        map.put("total", "2300.00");
        sleep(2000);
        return map;
    }
    
    @GetMapping("/product/{id}")
    public Map<String, Object> product(@PathVariable int id) {
        HashMap<String, Object> map = new HashMap<>();
        if (id == 1) {
            map.put("name", "小爱音箱");
            map.put("price", 300);
        } else if (id == 2) {
            map.put("name", "小米手机");
            map.put("price", 2000);
        }
        map.put("id", id);
        sleep(1000);
        return map;
    }
    
    @GetMapping("/logistics/{id}")
    public Map<String, Object> logistics(@PathVariable int id) {
        HashMap<String, Object> map = new HashMap<>();
        map.put("id", id);
        map.put("name", "中通快递");
        sleep(2500);
        return map;
    }
    
    private void sleep(int millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

rest 远程调用

RestTemplate restTemplate = new RestTemplate();
log.debug("begin");
ExecutorService service = Executors.newCachedThreadPool();
CountDownLatch latch = new CountDownLatch(4);

Future<Map<String,Object>> f1 = service.submit(() -> {
    Map<String, Object> r =
        restTemplate.getForObject("http://localhost:8080/order/{1}", Map.class, 1);
    latch.countDown();
    return r;
});
Future<Map<String, Object>> f2 = service.submit(() -> {
    Map<String, Object> r =
        restTemplate.getForObject("http://localhost:8080/product/{1}", Map.class, 1);
    latch.countDown();
    return r;
});
Future<Map<String, Object>> f3 = service.submit(() -> {
    Map<String, Object> r =
        restTemplate.getForObject("http://localhost:8080/product/{1}", Map.class, 2);
    latch.countDown();
    return r;
});
Future<Map<String, Object>> f4 = service.submit(() -> {
    Map<String, Object> r =
        restTemplate.getForObject("http://localhost:8080/logistics/{1}", Map.class, 1);
    latch.countDown();
    return r;
});
System.out.println(f1.get());
System.out.println(f2.get());
System.out.println(f3.get());
System.out.println(f4.get());

latch.await();
log.debug("执行完毕");
service.shutdown();

这里不用 CountDownLatch;，应该也可以，future#get本来就是阻塞的

执行结果

19:51:39.711 c.TestCountDownLatch [main] - begin 
{total=2300.00, id=1} 
{price=300, name=小爱音箱, id=1} 
{price=2000, name=小米手机, id=2} 
{name=中通快递, id=1} 
19:51:42.407 c.TestCountDownLatch [main] - 执行完毕

2.CyclicBarrier

[ˈsaɪklɪk ˈbæriɚ] 循环栅栏，用来进行线程协作，等待线程满足某个计数。构造时设置『计数个数』，每个线程执行到某个需要“同步”的时刻调用 await() 方法进行等待，当等待的线程数满足『计数个数』时，继续执行.

CyclicBarrier cb = new CyclicBarrier(2); // 个数为2时才会继续执行

new Thread(()->{
    System.out.println("线程1开始.."+new Date());
    try {
        cb.await(); // 当个数不足时，等待
    } catch (InterruptedException | BrokenBarrierException e) {
        e.printStackTrace();
    }
    System.out.println("线程1继续向下运行..."+new Date());
}).start();

new Thread(()->{
    System.out.println("线程2开始.."+new Date());
    try { 
        Thread.sleep(2000); 
    } catch (InterruptedException e) {
    }
    try {
        cb.await(); // 2 秒后，线程个数够2，继续运行
    } catch (InterruptedException | BrokenBarrierException e) {
        e.printStackTrace();
    }
    System.out.println("线程2继续向下运行..."+new Date());
}).start();

注意 CyclicBarrier 与 CountDownLatch 的主要区别在于 CyclicBarrier 是可以重用的， CyclicBarrier 可以被比喻为『人满发车』

被拯救的威尼斯
关注
专栏目录
【多线程笔记01】多线程之CountDownLatch介绍及其使用
✅ Java 开发工程师，从事 Web 应用程序的研发，擅长 Spring、SpringBoot 等技术。 ✅ 热爱编程，业余时间学习新知识，通过 CSDN 记录学习心得和笔记内容。
09-30 1309
CountDownLatch是JDK提供的一个多线程间通信的类，该类位于【java.util.concurrent】包下，CountDownLatch主要用于一个线程需要等待另一个线程执行完成之后，才可以继续执行的场景里面。CountDownLatch底层是基于AQS（抽象队列同步器）实现的，它的基本原理大致如下所示：创建CountDownLatch对象的时候，指定一个线程数量，此时内部会维护一个state计数器，用于表示线程的数量。这个时候，自己就可以创建一些子线程处理相应的业务逻辑。
多线程之CountdownLatch应用
ABestRookie的博客
08-24 974
从运行结果来看, 都是两秒后,线程才继续往下执行,即当CyclicBarrier线程等于设置值时,才能向下执行后续操作. 当CyclicBarrier归零后, 又恢复设置值, 即可重用机制. ( CountDownLatch没有可重用机制, 类似一次性工具,使用后即功能失效)构造时设置『计数个数』，每个线程执 行到某个需要“同步”的时刻调用 await() 方法进行等待，当等待的线程数满足『计数个数』时，继续执行.在平常的微服务项目中, 都是通过feign接口,互相调用不同业务的模块,涉及到多个远程调用.
countdownlatch用法
weixin_34235457的博客
03-29 99
public void await() throws InterruptedException { };   //调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行 public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };  //和await()类似，只不过等待一...
Java多线程编程-（6）-两种常用的线程计数器CountDownLatch和循环屏障CyclicBarrier
徐刘根的博客
10-12 8151
前几篇：Java多线程编程-（1）-线程安全和锁Synchronized概念Java多线程编程-（2）-可重入锁以及Synchronized的其他基本特性Java多线程编程-（3）-线程本地ThreadLocal的介绍与使用Java多线程编程-（4）-线程间通信机制的介绍与使用Java多线程编程-（5）-使用Lock对象实现同步以及线程间通信倒计时CountDownLatchCountDownLat
多线程之CountdownLatch
ABestRookie的博客
08-23 313
构造参数用来初始化等待计数值，await() 用来等待计数归零，countDown() 用来让计数减一.CountdownLatch, 用来进行线程同步协作，等待所有线程完成倒计时.
JUC笔记
qq_44789658的博客
07-25 939
JUC 基础知识
尚硅谷JUC视频笔记整理,很详细和全面，帮你迅速掌握JUC
12-27
本笔记整理涉及了JUC的内存可见性、volatile关键字以及CAS算法和原子变量等多个方面，以下是对这些知识点的详细说明。 ### 内存可见性 在多线程环境下，内存可见性是指当一个线程修改了某个共享变量的值，其他线程...
JUC个人笔记1
08-04
在Java并发编程中，"JUC个人笔记1"主要探讨了多线程并发控制的一些核心概念和技巧。首先，遵循高内聚低耦合的原则，将线程的操作与资源类进行解耦，使得代码结构更加清晰，易于维护。在多线程交互中，特别是涉及到`...
JUC详细笔记
leedoc的博客
11-05 903
此笔记根据黑马JUC课程整理 1.JUC概述 1.1什么是juc 在 Java 中，线程部分是一个重点，本篇文章说的 JUC 也是关于线程的。JUC就是 java.util .concurrent 工具包的简称。这是一个处理线程的工具包，JDK 1.5 开始出现的。 1.2 线程和进程概念 1.进程和线程 进程（Process） 是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。 在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其
个人学习JUC代码笔记总集
07-27
这个压缩包文件“个人学习JUC代码笔记总集”显然是一个个人的学习资源，记录了对JUC组件的理解和应用实例，特别适合已经有一定Java基础，想要深入学习并发编程的开发者。 JUC的主要目标是简化并发编程，提高多线程...
多线程 - CountDownLatch
最新发布
学无止境
05-12 247
CountDownLatch 的作用是在一个或多个线程等待其他线程完成执行某个操作后再继续执行。
多线程等待所有子线程执行完使用总结（2）——CountDownLatch使用和源码初步分析...
baorant24的博客
02-16 173
问题背景 我们在日常开发和学习过程中，经常会使用到多线程的场景，其中我们经常会碰到，我们代码需要等待某个或者多个线程执行完再开始执行，上一篇文章中(参考 https://blog.51cto.com/baorant24/6059489 )，我们介绍了object的wait()和notify()，以及线程的join()方法来...
Java - 多线程之 -- CountDownLatch
cmyperson的博客
07-06 693
开发中最常见的场景，在主线程中开启多线程并执行任务，主线程需要等待所有子线程执行完毕后再进行处理的场景。 在CountDownLatch出现之前，一般都是使用线程的join()方法来实现，但是join不够灵活，不能够满足不同场景的需要，所以JDK后来提供了CountDownLatch，用于同步。 一、CountDownLatch使用实例 public class JoinCountDownLatch { // 创建一个CountDownLatch实例 private static..
多线程工具CountDownLatch使用
南有南无
11-10 242
一：CountDownLatch概念 CountDownLatch是一个同步工具类，用来协调多个线程之间的同步，或者说起到线程之间的通信（而不是用作互斥的作用）。 二：CountDownLatch的用法 CountDownLatch典型用法： 某一线程在开始运行前等待n个线程执行完毕。将CountDownLatch的计数器初始化为new CountDownLatch(n)，每当一个任务线...
多线程环境下CountDownLatch的用法
James-Tom的博客
04-24 580
1、概述 谷歌直译：倒数计时 还有一些其他翻译：计数减小门闩，倒计时闩锁 CountDownLatch类所在的包路径： java.util.concurrent.CountDownLatch 一种同步辅助类，它允许一个或多个线程等待，直到在其他线程中执行的一组操作完成为止。 使用场景：在主线程中创建多个子线程，等待所有子线程执行完成之后，再切换到主线程等待位置并往下继续执行。 2、关键方法、函数 ...
使用多线程和CountDownLatch优化代码
～
06-29 482
代码跑不动了？加入多线程搞定
java循环屏障,使用CountDownLatch或循环屏障对多线程代码进行单元测试 -Xebia
weixin_28692817的博客
03-10 197
随着处理器比以往包装更多的内核，并发编程已成为最有效利用它们的最前沿。但是，事实是并发程序的设计，编写，测试和维护要困难得多。因此，如果我们毕竟可以为并发程序编写有效且自动化的测试用例，则可以解决其中的大部分问题。CountDownLatch@Testpublic void should_publish_an_article_using_count_down_latch_to_fix() thro...
java多线程 CountDownLatch对象的简单使用
Scott
03-12 319
一、概述 CountDownLatch对象可以使一条或多条线程阻塞，直到CountDownLatch的state变量的值为 0 时阻塞的线程才得以继续进行。这个过程由一个计数变量和两个操作组成。 二、主要方法。 void await(): 除非线程被中断，否则强制阻塞线程直到计数变量为0。当计数变量为0时，该方法立即返回。线程被中断时抛出异常。 boolean await(long timeo...
多线程学习笔记-CountDownLatch
相信明天的博客
08-26 180
CountDownLatch介绍 CountDownLatch是一个同步工具类，它允许一个或多个线程一直等待，直到其他线程执行完后再执行。 CountDownLatch是在java1.5被引入的，跟它一起被引入的并发工具类还有CyclicBarrier、Semaphore、ConcurrentHashMap和BlockingQueue，它们都存在于java.util.concurrent包下 CountDownLatch原理 CountDownLatch是通过一个计数器来实现的，计数器的初始化值为线程的数量
Java并发编程JUC笔记：DougLea的并发工具包解析
"这篇笔记详细介绍了Java并发编程中的核心组件，主要基于JDK 17，涵盖了java.util.concurrent工具包的使用以及线程与进程的相关概念。" 在Java并发编程中，`java.util.concurrent`(JUC) 工具包扮演着至关重要的角色...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值