高并发编程之Exchanger工具类讲解

最新推荐文章于 2023-06-08 13:53:53 发布
最新推荐文章于 2023-06-08 13:53:53 发布
阅读量267 收藏 2
点赞数 3
分类专栏： 并发 文章标签： Exchanger
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42146366/article/details/87884783
版权

一、Exchanger介绍
①、Exchanger，并发工具类，用于线程间的数据交换。
②、两个线程，两个缓冲区，一个线程往一个缓冲区里面填数据，另一个线程从另一个缓冲区里面取数据。当填数据的线程将缓冲区填满时，或者取数据的线程将缓冲区里的数据取空时，就主动向对方发起交换缓冲区的动作，而交换的时机是，一个缓冲区满，另一个缓冲区空。

注意：使用Exchanger来对线程进行数据操作时，线程必须是成对的（线程数量为双数）。

二、介绍Exchanger两个重要方法
①、exchange(V x)：等待另一个线程到达此交换点（除非当前线程被中断），然后将给定的对象传送给该线程，并接收该线程的对象。

package chapter3.exchanger;

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

/**
 * @author czd
 */
public class ExchangerTest1 {
    public static void main(String[] args) {
        final Exchanger<String> exchanger = new Exchanger<>();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "开始启动....");
                try {
                    String result = exchanger.exchange(" 我是来自Thread-A发送的数据！");
                    System.out.println(Thread.currentThread().getName() + " Result: " + result);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }

            }
        },"Thread-A").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "开始启动....");
                try {
                    TimeUnit.SECONDS.sleep(5);
                    String result = exchanger.exchange(" 我是来自Thread-B发送的数据！");
                    System.out.println(Thread.currentThread().getName() + " Result: " + result);
                }catch (Exception e){
                    e.printStackTrace();
                }

            }
        },"Thread-B").start();
    }
}

输出结果
在这里插入图片描述

②、exchange(V x, long timeout, TimeUnit unit)：等待另一个线程到达此交换点（除非当前线程被中断，或者超出了指定的等待时间），然后将给定的对象传送给该线程，同时接收该线程的对象。

package chapter3.exchanger;

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

/**
 * @author czd
 */
public class ExchangerTest1 {
    public static void main(String[] args) {
        final Exchanger<String> exchanger = new Exchanger<>();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "开始启动....");
                try {
                    String result = exchanger.exchange(" 我是来自Thread-A发送的数据！",3,TimeUnit.SECONDS);
                    System.out.println(Thread.currentThread().getName() + " Result: " + result);
                }catch (InterruptedException e){
                    e.printStackTrace();
                } catch (TimeoutException e){
                    System.out.println("超时了！");
                }

            }
        },"Thread-A").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "开始启动....");
                try {
                    TimeUnit.SECONDS.sleep(5);
                    String result = exchanger.exchange(" 我是来自Thread-B发送的数据！");
                    System.out.println(Thread.currentThread().getName() + " Result: " + result);
                }catch (Exception e){
                    e.printStackTrace();
                }

            }
        },"Thread-B").start();
    }
}

输出结果
在这里插入图片描述

三、提出疑问–A：当使用Exchanger对两个线程进行数据交换时，线程A发送的东西，与线程B接收到的东西是否是一样的？（一样是指地址是否正确，而不仅仅是值一样）

下面是一个验证地址是否一样的代码案例

package chapter3.exchanger;

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

/**
 * @author czd
 */
public class ExchangerTest2 {
    public static void main(String[] args) {
        final Exchanger<Object> exchanger = new Exchanger<>();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "开始启动....");
                try {
                    Object object = new Object();
                    Object obj = exchanger.exchange(object);
                    System.out.println(Thread.currentThread().getName() + " Thread-A send Object: " + object);
                    System.out.println(Thread.currentThread().getName() + " Thread-A get Object: " + obj);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }

            }
        },"Thread-A").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "开始启动....");
                try {
                    TimeUnit.SECONDS.sleep(5);
                    Object object = new Object();
                    Object obj = exchanger.exchange(object);
                    System.out.println(Thread.currentThread().getName() + " Thread-B send Object: " + object);
                    System.out.println(Thread.currentThread().getName() + " Thread-B get Object: " + obj);
                }catch (Exception e){
                    e.printStackTrace();
                }

            }
        },"Thread-B").start();
    }
}

输出结果
在这里插入图片描述
由图可以看出，线程A发送的东西与线程B接收到的东西是一样的，即连地址都是一样的

四、提出疑问–B：当使用Exchanger对两个线程进行数据交换时，是不是只能交换一次？能否多次的对两个线程进行数据的交换？

下面是一个验证是否能多次进行数据交换的代码案例

package chapter3.exchanger;

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

/**
 * @author czd
 */
public class ExchangerTest3 {
    public static void main(final String[] args) {
        final Exchanger<Integer> exchanger = new Exchanger<>();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "开始启动....");
                while (true){
                    try {
                        AtomicInteger atomicInteger = new AtomicInteger(1);
                        atomicInteger.set(exchanger.exchange(atomicInteger.get()));
                        System.out.println("Thread-A Value:" + atomicInteger.get());
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }


            }
        },"Thread-A").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "开始启动....");
                while (true){
                    try {
                        AtomicInteger atomicInteger = new AtomicInteger(2);
                        atomicInteger.set(exchanger.exchange(atomicInteger.get()));
                        System.out.println("Thread-B Value:" + atomicInteger.get());
                        TimeUnit.SECONDS.sleep(2);
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }


            }
        },"Thread-B").start();
    }
}

输出结果
在这里插入图片描述
由图可以看出，使用Exchanger可以对两个线程进行多次的数据交换

住手丶让我来
关注
专栏目录
并发编程——并发工具类.pdf
06-06
标题“并发编程——并发工具类.pdf”预示了文档将重点讲解Java中用于实现并发的工具类。描述“关于java中线程的一些基础知识详解文档和知识点，内容详细，通俗易懂，非常适合当接触线程知识的同学，以及复习线程理论...
汪文君高并发编程实战视频资源下载.txt
08-08
 高并发编程第三阶段21讲 Exchanger工具的使用以及常见问题分析-上_.mp4  高并发编程第三阶段22讲 Exchanger工具的使用以及常见问题分析-下_.mp4  高并发编程第三阶段23讲 Semaphore工具的介绍以及借助于...
并发工具类之 Exchanger
明月燃雨
12-29 192
Exchanger (交换者) 是一个用于线程间协作的工具类。 Exchanger 用于进行线程间的数据交换。 两个线程通过 exchange() 方法交换数据，第一个线程执行到 exchange() 方法后会一直等待第二个线程也执行 exchange() 方法，当两个线程都到达同步点后，这两个线程就可以交换数据。测试代码如下： public class TestExchanger { private static final Exchanger<String> exchanger =
J.U.C之并发工具类：Exchanger
wh柒八九的博客
09-01 232
本文来说下J.U.C之并发工具类：Exchanger 文章目录概述 概述 前面三篇博客分别介绍了CyclicBarrier、CountDownLatch、Semaphore，现在介绍并发工具类中的最后一个Exchange。Exchange是最简单的也是最复杂的，简单在于API非常简单，就一个构造方法和两个exchange()方法，最复杂在于它的实现是最复杂的（反正我是看晕了的）。 在API是这么介绍的：可以在对中对元素进行配对和交换的线程的同步点。每个线程将条目上的某个方法呈现给 exchange 方.
Exchanger 并发工具类
chuteng3602的博客
09-12 145
JDK1.5中有一个Exchanger类，可以用来完成线程间的数据交换。 类java.util.concurrent.Exchanger提供了一个同步点，在这个同步点，一对线程可以交换数据。每个线程通过exchange()方法的入口提供数据给他的伙伴线程，并接收他的伙伴线程提供的数...
并发工具：Exchanger工具
wyaoyao93的博客
04-22 204
文章目录1 Exchanger工具介绍2 一对线程间的数据交换2.1 Demo 1 Exchanger工具介绍 Exchanger（交换器），从字面意思来看它的主要作用就是用于交换，Exchanger简化了两个线程之间的数据交互，并且提供了两个线程之间的数据交换点，Exchanger等待两个线程调用其exchange()方法。调用此方法时，交换机会交换两个线程提供给对方的数据。 2 一对线程间的数据交换 Exchanger在某种程度上可以看成是生产者和消费者模式的实现，但是它重点关注的是数据交换，所谓交换就
高并发之Exchanger
tommer911
03-08 154
高并发之Exchanger
java高并发编程第一版
06-06
《Java高并发编程》第一版是一本专注于Java平台上的并发编程技术的专业书籍。在Java开发领域，高并发编程是至关重要的技能，特别是在大型分布式系统、云计算以及互联网应用中。本书旨在帮助开发者理解和掌握如何在...
汪文君高并发编程实战视频资源全集
08-08
 高并发编程第三阶段21讲 Exchanger工具的使用以及常见问题分析-上_.mp4  高并发编程第三阶段22讲 Exchanger工具的使用以及常见问题分析-下_.mp4  高并发编程第三阶段23讲 Semaphore工具的介绍以及借助于...
java高并发程序设计(原版电子书)
03-19
5. **并发工具类**：介绍`CountDownLatch`、`CyclicBarrier`、`Semaphore`和`Exchanger`等并发工具类，用于协调多个线程间的同步和协作。 6. **并发设计模式**：讨论适用于并发编程的设计模式，如生产者-消费者模式...
Exchanger工具类
但求成长，不求成功，让成功成为成长的必然结果，这就是成功最正确的道路
03-25 523
//Exchanger //用于实现两个人之间的数据交换，每个人在完成一定的事务后想与对方交换数据， //第一个先拿出数据的人将一直等待第二个人拿着数据到来时，才能彼此交换数据 public class ExchangerTest { public static void main(String[] args) { ExecutorService service = Execu
Java并发工具类（三）Exchanger
java界的小学生
02-13 826
Java并发工具类（三）Exchanger 在J.U.C并发包中提供了一些工具类，可以供我们在日常的开发中，根据不同的情况去进行一些相关的并发控制，具体的类有： CountDownLatch Semaphore Exchanger CyclicBarrier Exchanger 概念 Exchanger是线程间协作的工具类,Exchanger用于进行线程间的数据交换,它提供一个同步点,在这个同...
Java并发（十六）：并发工具类——Exchanger
weixin_34178244的博客
11-19 82
Exchanger（交换者）是一个用于线程间协作的工具类。Exchanger用于进行线程间的数据交换。它提供一个同步点，在这个同步点两个线程可以交换彼此的数据。这两个线程通过exchange方法交换数据， 如果第一个线程先执行exchange方法，它会一直等待第二个线程也执行exchange，当两个线程都到达同步点时，这两个线程就可以交换数据，将本线程生产出来的数据传递给对方。 举例 cl...
并发-Exchanger
进阶的小程媛儿
06-02 265
Exchanger Exchanger是两个任务之间交换对象的栅栏。当这些任务进入栅栏时，各自拥有一个对象，当它们离开时，它们都拥有之前由对象持有的对象。 Exchanger的典型应用场景是：一个任务在创建对象，这些对象的生产代价很高昂，而另一个任务在消费这些对象。通过这种方式，可以有更多的对象在被创建的同时被消费。 package com21concurrent; import co...
并发编程系列之Exchanger
热门推荐
姑苏城外（り寂寞
06-18 1万+
前言 上面我们介绍了信号量，再来说说交换者，这个东西用的不是很多，所以一般也不被经常关注，但是我们还是最好了解下，下面我将从什么是Exchanger以及如何使用Exchanger两个方面谈谈这个用于线程间协调的工具类。 什么是Exchanger？ Exchanger主要是用于线程之间进行数据交换的，提供一个同步点，在这个同步点，两个线程可以交换彼此的数据；两个线程通过Exchanger方法来进行交换，当第一个线程先执行Exchanger（）方法，他会一直等待第二个线程也执行Exchanger方法.
【死磕Java并发】—–J.U.C之并发工具类：Exchanger
Elon Zero的博客
09-26 160
Table of Contents 应用示例 实现分析 前面三篇博客分别介绍了CyclicBarrier、CountDownLatch、Semaphore，现在介绍并发工具类中的最后一个Exchange。Exchange是最简单的也是最复杂的，简单在于API非常简单，就一个构造方法和两个exchange()方法，最复杂在于它的实现是最复杂的（反正我是看晕了的）。 在API是这么介绍的：可以...
并发编程之Exchanger原理与使用
最新发布
meser88的博客
06-08 1310
在JUC包中，除了一些常用的或者说常见的并发工具类(ReentrantLock，CountDownLatch，CyclicBarrier，Semaphore)等，还有一个不常用的线程同步器类 —— Exchanger。Exchanger是适用在两个线程之间数据交换的并发工具类，它的作用是找到一个同步点，当两个线程都执行到了同步点(exchange方法)之后(有一个没有执行到就一直等待，也可以设置等待超时时间)，就将自身线程的数据与对方交换。
Java并发之Exchanger（交换者）
jessDL的博客
09-13 262
转：https://blog.csdn.net/tongdanping/article/details/79589253 Exchanger（交换者） Exchanger是一个线程间提供数据交换功能的写作工具，他提供了一个同步点，在这个同步点，两个线程可以交换彼此的数据。线程间通过调用excahange（）方法交换数据，如果第一个线程先到达同步点，执行exchange方法，那么他会一直在同步点...
java并发编程-Exchanger
qinxiaojian1028的博客
01-26 218
Exchanger 作用：两个线程之间可以传输数据，exchange()方法具有阻塞特色，此方法调用后，等待其他线程来取得数据，如果没有其他线程取得数据，则一直阻塞等待,exchange(V x, long timeout, TimeUnit unit) 设置超时时间 测试代码： public class TestThreadA extends Thread{     private Exchan...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值