5.5. Java并发工具类(如CountDownLatch、CyclicBarrier等)

这篇具有很好参考价值的文章主要介绍了5.5. Java并发工具类(如CountDownLatch、CyclicBarrier等)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

5.5.1 CountDownLatch

CountDownLatch是一个同步辅助类,它允许一个或多个线程等待,直到其他线程完成一组操作。CountDownLatch有一个计数器,当计数器减为0时,等待的线程将被唤醒。计数器只能减少,不能增加。

示例:使用CountDownLatch等待所有线程完成任务

假设我们有一个任务需要三个子任务完成,我们可以使用CountDownLatch来等待所有子任务完成。

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);

        for (int i = 1; i <= 3; i++) {
            final int taskNumber = i;
            new Thread(() -> {
                System.out.println("Task " + taskNumber + " started");
                try {
                    Thread.sleep(1000 * taskNumber);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Task " + taskNumber + " completed");
                latch.countDown();
            }).start();
        }

        System.out.println("Waiting for all tasks to complete...");
        latch.await();
        System.out.println("All tasks completed");
    }
}

在这个示例中,我们创建了一个CountDownLatch并设置初始计数器为3。每个子任务完成后,调用latch.countDown()减少计数器。主线程调用latch.await()等待所有子任务完成。

5.5.2 CyclicBarrier

CyclicBarrier是一个同步辅助类,它允许一组线程相互等待,直到所有线程都准备好继续执行。当所有线程都到达屏障点时,屏障将打开。CyclicBarrier可以重复使用。

示例:使用CyclicBarrier同步多个线程

假设我们有三个线程需要在某个点同步,我们可以使用CyclicBarrier实现这个目的。

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

public class CyclicBarrierExample {
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(3, () -> System.out.println("All threads are ready to proceed"));

        for (int i = 1; i <= 3; i++) {
            final int taskNumber = i;
            new Thread(() -> {
                System.out.println("Task " + taskNumber + " is ready");
                try {
                    barrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println("Task " + taskNumber + " is proceeding");
            }).start();
        }
    }
}

在这个示例中,我们创建了一个CyclicBarrier并设置参与者数量为3。每个线程在准备好继续执行之前调用barrier.await()。当所有线程都准备好时,屏障将打开,所有线程将继续执行。

5.5.3 Semaphore

Semaphore是一个计数信号量,它维护了一个许可集。线程可以请求许可,如果有可用的许可,线程将获得许可并继续执行。否则,线程将阻塞,直到有可用的许可。许可可以由任何线程释放。Semaphore可用于实现资源池、限制并发访问等。

示例:使用Semaphore限制并发访问

假设我们有一个只能同时处理三个请求的服务器,我们可以使用Semaphore来实现并发访问限制。

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);

        for (int i = 1; i <= 10; i++)            final int clientNumber = i;
            new Thread(() -> {
                try {
                    System.out.println("Client " + clientNumber + " is trying to connect");
                    semaphore.acquire();
                    System.out.println("Client " + clientNumber + " is connected");
                    Thread.sleep(2000);
                    System.out.println("Client " + clientNumber + " is disconnected");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            }).start();
        }
    }
}

在这个示例中,我们创建了一个Semaphore并设置初始许可数量为3。每个客户端线程在连接服务器之前调用semaphore.acquire()请求许可。当许可可用时,线程将获得许可并继续执行。线程完成后,调用semaphore.release()释放许可。

5.5.4 Exchanger

Exchanger是一个同步辅助类,它允许两个线程在一个临界点交换数据。当两个线程都到达交换点时,它们将交换数据。Exchanger可以用于遗传算法、管道设计等。

示例:使用Exchanger交换数据

假设我们有两个线程,一个生成数据,另一个处理数据。我们可以使用Exchanger在这两个线程之间交换数据。

import java.util.concurrent.Exchanger;

public class ExchangerExample {
    public static void main(String[] args) {
        Exchanger<String> exchanger = new Exchanger<>();

        new Thread(() -> {
            try {
                String data = "Data from producer";
                System.out.println("Producer is sending: " + data);
                String receivedData = exchanger.exchange(data);
                System.out.println("Producer received: " + receivedData);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(() -> {
            try {
                String data = "Data from consumer";
                System.out.println("Consumer is sending: " + data);
                String receivedData = exchanger.exchange(data);
                System.out.println("Consumer received: " + receivedData);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

在这个示例中,我们创建了一个Exchanger。生产者和消费者线程在交换数据前调用exchanger.exchange(data)。当两个线程都到达交换点时,它们将交换数据。

5.5.5 Phaser

Phaser是一个灵活的同步辅助类,它允许一组线程相互等待,直到所有线程都准备好继续执行。与CyclicBarrier类似,但Phaser更加灵活,可以动态调整参与者数量和支持多个阶段。

示例:使用Phaser同步多个线程

假设我们有三个线程需要在某个点同步,我们可以使用Phaser实现这个目的。

import java.util.concurrent.Phaser;

public class PhaserExample {
    public static void main(String[] args) {
        Phaser phaser = new Phaser(3);

        for (int i = 1; i <= 3; i++) {
            final int taskNumber = i;
            new Thread(() -> {
                System.out.println("Task " + taskNumber + " is ready");
                phaser.arriveAndAwaitAdvance();
                System.out.println("Task " + taskNumber + " is proceeding");
            }).start();
        }
    }
}

在这个示例中,我们创建了一个Phaser并设置参与者数量为3。每个线程在准备好继续执行之前调用phaser.arriveAndAwaitAdvance()。当所有线程都准备好时,屏障将打开,所有线程将继续执行。

这些并发工具类为Java多线程编程提供了强大的支持,帮助我们更轻松地实现各种同步和并发场景。希望这些示例能帮助你理解并掌握这些工具类的用法。
推荐阅读:

https://mp.weixin.qq.com/s/dV2JzXfgjDdCmWRmE0glDA

https://mp.weixin.qq.com/s/an83QZOWXHqll3SGPYTL5g

5.5. Java并发工具类(如CountDownLatch、CyclicBarrier等)文章来源地址https://www.toymoban.com/news/detail-466240.html

到了这里,关于5.5. Java并发工具类(如CountDownLatch、CyclicBarrier等)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Java并发工具类

    JDK并发包中常用并发工具类: CountDownLatch、CyclicBarrier和Semaphore工具类提供了一种并发流程控制的手段; Exchanger工具类则提供了在线程间交换数据的一种手段。 CountDownLatch允许一个或多个线程等待其他线程完成操作。 需求:解析一个Excel里多个sheet的数据,可以考虑使用多线程

    2024年02月11日
    浏览(37)
  • Java中的并发工具类

    JUC篇:volatile可见性的实现原理 JUC篇:synchronized的应用和实现原理 JUC篇:用Java实现一个简单的线程池 JUC篇:java中的线程池 JUC篇:ThreadLocal的应用与原理 在JDK的并发包里提供了几个非常有用的并发工具类。CountDownLatch、CyclicBarrier和 Semaphore工具类提供了一种并发流程控制的手

    2023年04月24日
    浏览(35)
  • 【Java基础】线程同步类 CountDownLatch

    ​ 关于作者:CSDN内容合伙人、技术专家, 从零开始做日活千万级APP。 专注于分享各领域原创系列文章 ,擅长java后端、移动开发、人工智能等,希望大家多多支持。 正好今天项目中用到了CountDownLatch,那我们正好总结一下,通过本文你可以学到什么是CountDownLatch及其原理,

    2024年02月12日
    浏览(47)
  • Java并发工具合集JUC大爆发!!!

    通常我们所说的并发包也就是java.util.concurrent(JUC),集中了Java并发的各种工具类, 合理地使用它们能帮忙我们快速地完成功能 。 作者: 博学谷狂野架构师 GitHub: GitHub地址 (有我精心准备的130本电子书PDF) 只分享干货、不吹水,让我们一起加油!😄 CountDownLatch是一个同步计

    2023年04月17日
    浏览(77)
  • java高并发系列 - 第34篇:google提供的一些好用的并发工具类

    java高并发系列第34篇。 环境:jdk1.8。 关于并发方面的,juc已帮我们提供了很多好用的工具,而谷歌在此基础上做了扩展,使并发编程更容易,这些工具放在guava.jar包中。 本文演示几个简单的案例,见一下guava的效果。 需要先了解的一些技术:juc中的线程池、Excecutors、Execu

    2024年02月16日
    浏览(40)
  • CountDownLatch介绍和使用【Java多线程必备】

    点击   Mr.绵羊的知识星球  解锁更多优质文章。 目录 一、介绍 二、特性 三、实现原理 四、适用场景 五、注意事项 六、实际应用     CountDownLatch 是 Java 中的一个并发工具类,用于协调多个线程之间的同步。其作用是让某一个线程等待多个线程的操作完成之后再执行。它可

    2024年02月05日
    浏览(50)
  • Java无锁并发工具类Unsafe.compareAndSwapLong方法

    compareAndSwapLong 方法是一个原子操作,通常用于并发编程中的无锁算法。它的作用是以原子方式比较并交换某个对象的一个long类型的字段。具体来说,它接收4个参数: Object obj : 需要操作的对象。 long offset :  obj 中要操作的字段的内存偏移量。 long expected : 预期的值,用于比较

    2024年02月10日
    浏览(31)
  • 进阶JAVA篇- Collcetions 工具类与集合的并发修改异常问题

    目录         1.0 集合的并发修改问题                 1.1 如何解决集合的并发修改问题         2.0 Collcetions 工具类的说明         我们可以简单的认为,就是使用迭代器遍历集合时,又同时在删除集合中的数据,程序就会出现并发修改异常的错误。 代码如下: 运行

    2024年02月07日
    浏览(41)
  • CyclicBarrier线程同步

    关于作者: CSDN内容合伙人、技术专家, 从零开始做 日活千万级APP ,带领团队单日营收超千万。 专注于分享各领域原创系列文章 ,擅长java后端、移动开发、商业化变现、人工智能等,希望大家多多支持。 我们继续总结学习 Java基础知识 ,温故知新。 本文涉及知识点: A

    2024年02月06日
    浏览(31)
  • 多线程基础(三)JUC并发包:Lock锁、CountDownLath、CyclicBarrier、Semaphore、LockSupport

    我们可以使用 ReentrantLock 来替代 Synchronized锁,实现方法为: 使用Synchronized是自动解锁的。但是使用lock锁,必须使用try-catch-finally包裹,在try中加锁,在finally中释放锁。 允许同一时刻多个读线程访问,但所有写线程均被阻塞。读写分离,并发性提升。 java中实现类的读写锁为

    2024年02月06日
    浏览(37)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包