九、Exchanger 线程间数据交换工具

最新推荐文章于 2022-09-01 18:14:50 发布

我想砍你

最新推荐文章于 2022-09-01 18:14:50 发布

阅读量150

点赞数

分类专栏：多线程文章标签：多线程

本文链接：https://blog.csdn.net/XZQ_STUD/article/details/112293789

版权

多线程专栏收录该内容

17 篇文章 0 订阅

订阅专栏

1、可以实现一对线程间数据交换，只能是一对线程之间

package day04.part1;

import java.util.concurrent.Exchanger;

/**
 * 线程间数据交换工具
 * 可以实现一对线程间数据交换，只能是一对线程之间
 * @author xzq
 */
public class ExchangerTest01 {

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

        Thread t1 = new Thread("线程1") {

            @Override
            public void run() {
                try {
                    String changeData = "人民币";
                    String threadName = Thread.currentThread().getName();
                    System.out.println(threadName + "：正准备把数据：" + changeData + "换出去");
                    System.out.println(threadName+"：需要：3秒才能到达交易地点");
                    Thread.sleep(3000);
                    System.out.println(threadName+"：已经到达交易地点");
                    String gainData = echg.exchange(changeData);
                    System.out.println(threadName + "：换回的数据为：" + gainData);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread("线程2") {

            @Override
            public void run() {
                try {
                    String changeData = "酱油";
                    String threadName = Thread.currentThread().getName();
                    System.out.println(threadName + "：正准备把数据：" + changeData + "换出去");
                    System.out.println(threadName+"：需要：1秒才能到达交易地点");
                    Thread.sleep(1000);
                    System.out.println(threadName+"：已经到达交易地点");
                    String gainData = echg.exchange(changeData);
                    System.out.println(threadName + "：换回的数据为：" + gainData);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        t1.start();
        t2.start();

    }

}

在这里插入图片描述
2、使用超时的方式进行交换，早到的会抛超时异常，迟到一方就会一直等待

package day04.part1;

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

/**
 * 线程间数据交换工具
 * 使用超时的方式进行交换
 * 早到的会抛超时异常，迟到一方就会一直等待
 * @author xzq
 */
public class ExchangerTest02 {

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

        Thread t1 = new Thread("线程1") {

            @Override
            public void run() {
                String threadName = Thread.currentThread().getName();
                try {
                    String changeData = "人民币";
                    System.out.println(threadName + "：正准备把数据：" + changeData + "换出去");
                    System.out.println(threadName+"：需要：1秒才能到达交易地点");
                    Thread.sleep(1000);
                    System.out.println(threadName+"：已经到达交易地点");
                    String gainData = echg.exchange(changeData,2, TimeUnit.SECONDS);
                    System.out.println(threadName + "：换回的数据为：" + gainData);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    System.out.println(threadName + "：等了2秒卖酱油的都还没到，不等了……");
                }
            }
        };

        Thread t2 = new Thread("线程2") {

            @Override
            public void run() {
                try {
                    String changeData = "酱油";
                    String threadName = Thread.currentThread().getName();
                    System.out.println(threadName + "：正准备把数据：" + changeData + "换出去");
                    System.out.println(threadName+"：需要：5秒才能到达交易地点");
                    Thread.sleep(5000);
                    System.out.println(threadName+"：已经到达交易地点");
                    String gainData = echg.exchange(changeData);
                    System.out.println(threadName + "：换回的数据为：" + gainData);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        t1.start();
        t2.start();

    }

}

在这里插入图片描述
3、交换时后是操作的同一个引用和同一个堆内存对象，所以必须考虑交换数据的线程安全问题

package day04.part1;

import java.util.concurrent.Exchanger;

/**
 * 线程间数据交换工具
 * 交换时后是操作的同一个引用和同一个堆内存对象
 * 所以必须考虑交换数据的线程安全问题
 * @author xzq
 */
public class ExchangerTest03 {

    public static void main(String[] args) {
        final Exchanger<int[]> echg = new Exchanger<>();

        Thread t1 = new Thread("线程1") {

            @Override
            public void run() {
                String threadName = Thread.currentThread().getName();
                try {
                    int[] changeData ={3,2,1};
                    System.out.println(threadName + "：正准备把数据：" + changeData + "换出去");
                    System.out.println(threadName+"：需要：1秒才能到达交易地点");
                    Thread.sleep(1000);
                    System.out.println(threadName+"：已经到达交易地点");
                    int[] gainData = echg.exchange(changeData);
                    System.out.println(threadName + "：换回的数据为：" + gainData);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread("线程2") {
            @Override
            public void run() {
                try {
                    int[] changeData = {1,2,3};
                    String threadName = Thread.currentThread().getName();
                    System.out.println(threadName + "：正准备把数据：" + changeData + "换出去");
                    System.out.println(threadName+"：需要：3秒才能到达交易地点");
                    Thread.sleep(3000);
                    System.out.println(threadName+"：已经到达交易地点");
                    int[] gainData = echg.exchange(changeData);
                    System.out.println(threadName + "：换回的数据为：" + gainData);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        t1.start();
        t2.start();

    }

}

在这里插入图片描述
4、是否能进行多次交换

package day04.part1;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.Exchanger;

/**
 * 线程间数据交换工具
 * 是否能进行多次交换
 * @author xzq
 */
public class ExchangerTest04 {
    public static void main(String[] args) {
        final Exchanger<List<String>> echg = new Exchanger<>();

        Thread t1 = new Thread("线程1") {

            @Override
            public void run() {
                String threadName = Thread.currentThread().getName();
                try {
                    List<String> syncChangeData = Collections.synchronizedList(new ArrayList<String>());
                    syncChangeData.add("D");
                    syncChangeData.add("E");
                    syncChangeData.add("F");
                    System.out.println(threadName + "：正准备把数据：" + syncChangeData + "换出去");
                    System.out.println(threadName+"：需要：1秒才能到达交易地点");
                    for(int i=0;i<5;i++){
                        Thread.sleep(1000);
                        System.out.println(threadName+"：已经到达交易地点");
                        List<String> gainData = echg.exchange(syncChangeData);
                        syncChangeData=gainData;
                        System.out.println(threadName + "：换回的数据为：" + gainData);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread("线程2") {
            @Override
            public void run() {
                try {
                    String threadName = Thread.currentThread().getName();
                    List<String> syncChangeData = Collections.synchronizedList(new ArrayList<String>());
                    syncChangeData.add("A");
                    syncChangeData.add("B");
                    syncChangeData.add("C");
                    System.out.println(threadName + "：正准备把数据：" + syncChangeData + "换出去");
                    for (int i = 0; i < 3; i++) {
                        System.out.println(threadName+"：需要：2秒才能到达交易地点");
                        Thread.sleep(2000);
                        System.out.println(threadName+"：已经到达交易地点");
                        List<String> gainData = echg.exchange(syncChangeData);
                        syncChangeData=gainData;
                        System.out.println(threadName + "：换回的数据为：" + syncChangeData);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        t1.start();
        t2.start();
    }
}

在这里插入图片描述

我想砍你

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
九、Exchanger 线程间数据交换工具

1、可以实现一对线程间数据交换，只能是一对线程之间package day04.part1;import java.util.concurrent.Exchanger;/** * 线程间数据交换工具 * 可以实现一对线程间数据交换，只能是一对线程之间 * @author xzq */public class ExchangerTest01 { public static void main(String[] args) { final Exchanger<S
复制链接

扫一扫

专栏目录