JUC工具包(二)Exchanger和Semaphore

最新推荐文章于 2024-08-15 14:47:41 发布
最新推荐文章于 2024-08-15 14:47:41 发布
阅读量106 收藏
点赞数
分类专栏： Java自学之路 # 高并发与多线程网络编程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46592754/article/details/105149693
版权

java.util.concurrent 工具包的使用(二)


Exchanger ( 交换器 )

-----作用-----

​ java.util.concurrent包中的Exchanger类可用于两个线程之间交换信息。可简单地将Exchanger对象理解为一个包含两个格子的容器，通过exchanger方法可以向两个格子中填充信息。当两个格子中的均被填充时，该对象会自动将两个格子的信息交换，然后返回给线程，从而实现两个线程的信息交换。


-----构造函数-----
构造函数作用备注
public Exchanger()构造一个Exchanger对象

-----常用API-----
API作用备注
public V exchange(V x) throws InterruptedException等待与另外的线程交换一个对象是个阻塞方法,可,可中断
public V exchange(V x, long timeout, TimeUnit unit)用第一个,有时间限制,会超时再2个线程交换的时候,如果一个线程提前结束,可能会导致另外一个线程死等待

-----代码示例-----

  1. Example 1 最简单的交换 Demo

    package myConcurrent.s2020_03_27;

import java.util.concurrent.Exchanger;

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

        new Thread(() -> {
            try {
                String call = "我是AAAA的消息";
                System.out.println(Thread.currentThread().getName() + " 发送了 >>> " + call);
                String str = exchanger.exchange(call);
                System.out.println(Thread.currentThread().getName() + " 收到了 >>> " + str);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"AAAAAA").start();

        new Thread(() -> {
            try {
                String call = "我是BBBB的消息";
                System.out.println(Thread.currentThread().getName() + " 发送了 >>> " + call);
                String str = exchanger.exchange(call);
                System.out.println(Thread.currentThread().getName() + " 收到了 >>> " + str);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"BBBBB").start();

    }
}

  2. Example 2测试有时间限制的方法 (注意 一旦一个设置了 超时延迟,要把另一个也要设,否则会有死等待的可能 )

    package myConcurrent.s2020_03_27;

import java.util.concurrent.Exchanger;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/**
 * 有时间限制
 * */
public class ExchangerExample2 {
    public static void main(String[] args) throws InterruptedException {
        final Exchanger<String> exchanger = new Exchanger<>();

        new Thread(() -> {
            try {
                String str = exchanger.exchange("ssdf",1, TimeUnit.SECONDS);
                System.out.println(str);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                System.out.println("超时了!");
                e.printStackTrace();
            }
        }).start();

        TimeUnit.SECONDS.sleep(2);
        
        new Thread(() -> {
            try {
                String str = exchanger.exchange("ssdf",1, TimeUnit.SECONDS);
                System.out.println(str);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                System.out.println("超时了!");
                e.printStackTrace();
            }
        }).start();
    }
}

  3. 由于交换,涉及了对象的发布,可能会导致一些线程安全的问题,因此对象的交换要和原子引用结合在一起

    package myConcurrent.s2020_03_27;

import java.util.concurrent.Exchanger;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

public class ExchangerExample3 {
    public static void main(String[] args) throws InterruptedException {
        final Exchanger<UnSafeObject> exchanger = new Exchanger<>();
        new Thread(() -> {
            UnSafeObject adf = new UnSafeObject("adf", 12);

            AtomicReference<UnSafeObject> reference = new AtomicReference<>(adf);
            try {
                UnSafeObject exchange = exchanger.exchange(reference.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(() -> {
            UnSafeObject object = new UnSafeObject("abc",1);

            AtomicReference<UnSafeObject> reference = new AtomicReference<>(object);
            try {
                UnSafeObject exchange = exchanger.exchange(reference.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }

    static class UnSafeObject {
        private String name;
        private int age;

        public void setName(String name) {
            this.name = name;
        }

        public void setAge(int age) {
            this.age = age;
        }

        public UnSafeObject(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public int getAge() {
            return age;
        }
    }
}



Semaphore ( 信号量 )

-----作用-----
  • 它是一个计数信号量
  • 一个更贴切的称呼----许可证管理器
  • 拥有这一组许可证

-----构造函数-----
构造函数作用备注
public Semaphore(int permits)构造一个拥有permits个的许可证的管理器permits并没有做什么限制,负数也是可以的
public Semaphore(int permits, boolean fair)同一,另一个参数是 是否 公平,如果是公平,尽量会使每个线程得到相同的抢占数量使用第一种构造,默认是不公平的

-----常用API-----
API作用备注
public void acquire() throws InterruptedException向管理器要一个许可证,如果没有了,就会陷入阻塞
public void acquire(int permits) throws InterruptedException作用和第一个方法一样,就是向管理器要permits个许可证
public void acquireUninterruptibly()作用和第一个方法一样,但是不会响应中断信号
public void acquireUninterruptibly(int permits)同第3个方法,申请的数量不同
public boolean tryAcquire()尝试向管理器要一个许可证,如果没有,就不要了.不会陷入阻塞,一种尝试
public boolean tryAcquire(int permits)尝试向管理器要permits个许可证,如果没有,就不要了
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException尝试一段时间向管理器要一个许可证,如果没有,就不要了,会有短暂的阻塞(能够响应中断)返回值就是有没有抢到
public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException同上
public void release()向管理器归还一个许可证
public void release(int permits)向管理器归还permits个许可证permits小于0会报错
public int availablePermits()精确的获得当前管理器还有多少个许可证可以用来实时监控这个管理器
public int drainPermits()获取当前管理器的所有许可证返回值是获得了多少个许可证
public final int getQueueLength()获得正在等待获取许可证的线程数量这是个估计值,不是十分精确,可是用来监控管理器用的方法

-----代码示例-----

  1. Example 1 测试了基本的使用 以及 一个 监控 管理器的实现

    package myConcurrent.s2020_03_27;

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

public class SemaphoreExample1 {
    public static void main(String[] args) throws InterruptedException {
        final Semaphore semaphore = new Semaphore(-1);
        //获取许可证超过时间的例子
        boolean flag = semaphore.tryAcquire(2, TimeUnit.SECONDS);
        System.out.println("是否获得了许可证 : " + flag);

        //给管理器补充一些许可证
        semaphore.release(11);

        //现在拥有10个许可证
        System.out.println("现在拥有个 " + semaphore.availablePermits() + " 可用的许可证");

        IntStream.range(0, 100).forEach(i -> {
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    Thread.sleep(1000);
                    System.out.println(i + "完成了工作!--");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();    //归还许可证
                }
            }).start();
        });

        Thread monitor = new Thread(() -> {
            while (true){
                int queueLength = semaphore.getQueueLength();
                int number = semaphore.availablePermits();
                System.out.println("==================================\n" +
                        "当前有" + queueLength + "个线程正在等待获取许可证\n" +
                        "当前有" + number + "个可用的许可证\n" +
                        "==============================");
                try {
                    Thread.sleep(1_000);
                } catch (InterruptedException ignore) {
                    break;
                }
            }
        });

        monitor.start();

        Thread.sleep(20_000);
        monitor.interrupt();
    }
}



感谢观看

记录萌新的学习经历

欢迎大佬来拍砖

TBS_Learner
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
thread.zip--狂神多线程+juc
03-18
《狂神多线程+juc》是一份针对Java并发编程深度学习的资源包，主要涵盖了Java多线程基础以及Java并发工具集（JUC）的高级应用。在Java编程中，多线程是提高程序效率、实现并发执行的重要手段，而JUC（Java ...
JUC
04-01
Java并发编程库（Java Concurrency Utility，简称JUC）是Java平台中用于高效并发处理的重要组件，主要包含在`java.util.concurrent`包及其子...在实际项目中，合理利用JUC工具能够极大地提升系统的并发性能和响应速度。
JUC包中的Exchanger类
去武帝城，战王仙芝
05-13 161
Exchanger类用于两个线程之间的信息交换。 举一个现场的例子： import java.util.concurrent.Exchanger; public class ExchangerTest { static Exchanger<String> exchanger = new Exchanger<>(); public static void main(String[] args) { new Thread(()->{
Java多线程 -- JUC包源码分析17 -- 弱一致性与无锁队列
软件开发与架构领域 -体系化知识分享
09-11 1425
–ConcurrentHashMap的弱一致性 –SynchronousQueue的弱一致性 –Exchanger的弱一致性 –Linux内核无锁队列的弱一致性 –总结经过前面一系列的源码分析，我们基本覆盖了JUC包的所有组件。在这诸多组件中，我们总是不断看到一个如影随行的东西：CAS。相当锁来讲，它的原子粒度更小，只是作用在一个基本变量上面（比如一个Integer, Long, 或者Ref
JUC同步锁原理源码解析六----Exchanger
woaimx_1314的博客
06-20 101
​ JDK中对Exchanger的定义是在一个同步线程点，配对的线程可以交换彼此的属性数据。每一个线程提交对象数据并调用exchange方法，匹配到一个线程并接受该线程携带的数据返回。当然Exchanger并不是说只有两个线程进行匹配，它也可以进行多对多的匹配，但是只有成对的线程可以匹配并交换数据成功。​ 到了这里，并发工具包常用的原子性工具类已经结束了，LockSupport由于直接调用底层的park方法，较为复杂，设计到JVM的源码，暂时能力有限，后续如果看懂了在进行更新。
JUC第三十讲：JUC工具类：Exchanger详解
Jet_qi的博客
10-15 295
本文是JUC第三十讲，JUC工具类: Exchanger详解。Exchanger是用于线程协作的工具类，主要用于两个线程之间的数据交换。
JUC 工具类之 Exchanger 详解
liuwg1226的专栏
09-13 717
一 Exchanger 简介 线程间的数据共享除了定义一个共享数据然后各个线程去访问这种方式外，还可以使用 Exchanger 交换数据。 Exchanger——交换器，是 JDK1.5 时引入的一个同步器，从字面上就可以看出，这个类的主要作用是：进行两个线程之间的数据交换。 Exchanger 有点类似于 CyclicBarrier，我们知道 CyclicBarrier 是一个栅栏，到达栅栏的线程需要等待其它一定数量的线程到达后，才能通过栅栏。 Exchanger 可以看成是一个双向栅栏，如下图： Th
JUC并发编程与源码分析视频课.zip
12-16
JUC是Java平台提供的一组高级并发工具包，它极大地简化了多线程编程，并提供了更高效、安全的并发解决方案。在本课程中，你将学习到如何利用这些工具来提升应用程序的并发性能，同时理解其底层实现原理。 课程内容...
JUC-master
03-21
4. **并发工具类（Synchronizers）**：包括CountDownLatch、CyclicBarrier、Semaphore等，它们提供了同步控制和协调不同线程间操作的能力。例如，CountDownLatch可以用于等待多个任务完成，CyclicBarrier则允许一组...
JAVA进阶补充
最新发布
2301_80150315的博客
08-15 541
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
进程间通信 ---共享内存
BUG制造机的博客
08-14 864
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 535
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 241
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
集合（1）
supercool7的博客
08-12 819
表示不同的类型集合，Collection、Map、List、Set、Queue、Deque等，以及辅助性质的接口Iterator、LinkIterator、Comparator、Comparable这些接口是为迭代和比较元素而准备。对接口的具体实现，主要常用的有：ArrayList、LinkedList、HashMap、HashSet、TreeMap等等。理解Java集合体系可以从三个层次：最上层的接口、中间的抽象类、最后的实现类。是所有集合框架的根接口，包含了对集合进行基本操作的方法。
【Markdown】Markdown 中的语言简称
EleganceJiaBao的博客
08-12 927
以下是常见编程语言、脚本语言、标记语言等在 Markdown 中的语言简称以及相应的示例：
Mybatis XML 数据源为 Oracle 之批量插入或更新 Merge Into 的具体介绍与使用
欢迎来到 ABin-阿斌的博客：写一生代码，创一世佳话，筑一览芳华。
08-12 673
由于近期在所开发的项目中，对于数据入库，有存在即更新，不存在则插入的需求，因此发现了 Oracle中的 MergeInto 命令。本文将对MergeInto的用法进行介绍并将 MergeInto 和批量插入进行结合，同时还会对在 MergeInto 开发中遇到的问题进行总结。MergeInto 命令是 Oracle9i 中新增的命令，有了 MergeInto 语句，我们对数据能够不仅仅只做单一的插入或单一的更新，而是可以将更新与插入一起操作。
构造方法，JavaBean，对象内存图，基础数据类型和引用数据类型
qq_63126439的博客
08-14 256
栈内存处理完数据之后会退出，指向推内存的箭头都会消失，当没有人指向他的时候，堆内存中的数据也会被移除。带参构造方法和无参数构造方法，两者方法名相同，但参数不同，这叫做构造方法的重载。方法区，新增元空间，把原来的方法区的多种功能进行了拆分。创造对象的时候，虚拟机会自动调用构造方法，作用是给成员变量进行初始化的。只要是看见new就会在堆内存创建新的空间，两个空间是独立的，互不影响。基础数据类型，在变量当中存储真实的数据值，和其他空间没有任何关系。使用其他空间的数值，自己的空间存储的是地址值。
基于JAVA生产制造执行系统设计与实现(源码+论文+讲解等)
程序员阿龙的博客
08-13 901
当下，如果 还依然使用纸质文档来记录并且管理相关信息，可能会出现很多问题，比如原始文件的丢失，因为采用纸质文档，很容易受潮或者怕火，不容易备份，需要花费大量的人员和资金来管理用纸质文档存储的信息，最重要的是数据出现问题寻找起来很麻烦，并且修改也困难，如果还这样操作会造成很大的资源浪费和经济损失。所以，对于本课题研究的产品生产制造信息的管理就需要有一款软件来代替手工操作，因此MES生产制造执行系统就应运而生。MES生产制造执行系统运用的工具包括Eclipse，Tomcat以及Navicat等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值