乐趣区

关于java:面了个-5-年-Java两个线程进行数据交换都不会我真是醉了

jiezi

面试总结

最近栈长面试了一个 5 年教训的 Java 程序员，简历和集体介绍都提到了精通 Java 多线程，于是我就问了几个多线程方面的问题：

1、实现多线程有哪几种形式，如何返回后果？

2、多个线程如何实现程序拜访？

3、两个线程如何进行数据交换？

4、如何统计 5 个线程的运行总耗时？

5、如何将一个工作拆分成多个子工作执行，最初合并后果？

大略问了他这几个问题，答的并不是太好，3、4、5 题都没有真正答上来，其实这几个问题在 JDK 包中都有答案，但他给的是他集体长期思考的计划，而且我集体感觉可能行不通。

工作 5 年了，这几个题都答不好，有点说不过去，我真是醉了。。

其中，1、2、4、5 题我都在公众号 Java 技术栈分享过相干的教程，也都在 Java 面试库 小程序上整顿好了，最近面试的看看，明天就分享一下第 3 题的参考答案。

第 3 题也是通过 JDK 中的 java.util.concurrent.Exchanger 类来实现的，并不需要咱们反复造轮子，这个工具类在 JDK 1.5 中就曾经引入了，并不是什么 “ 新个性 ”。

Exchanger 简介

Exchanger 就是线程之间的数据交换器，只能用于两个线程之间的数据交换。

Exchanger 提供了两个公开办法：

1、只带泛型 V（替换的数据对象）的办法，线程始终阻塞，直到其余任意线程和它替换数据，或者被线程中断；线程中断也是一门学识，栈长在公众号 Java 技术栈曾经分享过，可在公众号搜寻浏览；

2、另外一个带工夫的办法，如果超过设置工夫还没有线程和它替换数据，就会抛出 TimeoutException 异样；

Exchanger 实战

简略数据交换

来一个两个线程失常数据交换的简略示例：

private static void test1() {Exchanger exchanger = new Exchanger();

    new Thread(() -> {
        try {
            Object data = "- 公众号 Java 技术栈 AAA";
            System.out.println(Thread.currentThread().getName() + data);

            // 开始替换数据
            data = exchanger.exchange(data);
            System.out.println(Thread.currentThread().getName() + data);
        } catch (InterruptedException e) {e.printStackTrace();
        }
    }).start();

    new Thread(() -> {
        try {
            Object data = "- 公众号 Java 技术栈 BBB";
            System.out.println(Thread.currentThread().getName() + data);

            // 开始替换数据
            data = exchanger.exchange(data);
            System.out.println(Thread.currentThread().getName() + data);
        } catch (InterruptedException e) {e.printStackTrace();
        }
    }).start();}

这段代码的逻辑：

1、创立并启动两个线程；

2、进行数据交换前先打印出本人线程的数据；

3、进行数据交换；

4、打印数据交换之后的数据；

输入后果：

从后果能够看出，线程 0、1 别离先打印出 A、B，数据交换之后，打印出了 B、A，数据交换失常！

超时数据交换

下面演示了两个线程的失常替换，上面再来一个带超时的示例：

private static void test2() {Exchanger exchanger = new Exchanger();

    new Thread(() -> {
        try {
            Object data = "- 公众号 Java 技术栈 AAA";
            System.out.println(Thread.currentThread().getName() + data);

            // 开始替换数据
            data = exchanger.exchange(data, 3000L, TimeUnit.MILLISECONDS);
            System.out.println(Thread.currentThread().getName() + data);
        } catch (Exception e) {e.printStackTrace();
        }
    }).start();}

当初只启动了一个线程，并且设置了超时工夫 3 秒。

输入后果：

首先线程输入了本人的数据，而后 3 秒后，并没有其余线程和它替换数据，所以抛出了超时异样，最初线程完结运行。

本文所有案例源代码曾经上传：https://github.com/javastacks…

中断数据交换

线程开始替换数据后，会始终阻塞直到其余任意线程和它替换数据，或者被中断、超时，下面演示了超时，上面这个示例演示一下中断。

private static void test3() {Exchanger exchanger = new Exchanger();

    new Thread(() -> {
        try {
            Object data = "- 公众号 Java 技术栈 AAA";
            System.out.println(Thread.currentThread().getName() + data);

            // 开始替换数据
            data = exchanger.exchange(data);
            System.out.println(Thread.currentThread().getName() + data);
        } catch (Exception e) {e.printStackTrace();
        }
    }).start();}

后果输入：

默认状况下不带超时设置会始终阻塞运行中……

当初我再退出一段中断的逻辑：

private static void test3() throws InterruptedException {Exchanger exchanger = new Exchanger();

    Thread thread = new Thread(() -> {
        try {
            Object data = "- 公众号 Java 技术栈 AAA";
            System.out.println(Thread.currentThread().getName() + data);

            // 开始替换数据
            data = exchanger.exchange(data);
            System.out.println(Thread.currentThread().getName() + data);
        } catch (Exception e) {e.printStackTrace();
        }
    });

    thread.start();

    // 线程中断
    Thread.sleep(3000L);
    thread.interrupt();}

主线程休眠 3 秒后，中断该线程。

输入后果：

输入后果 3 秒后，线程被中断了，抛出了中断异样，线程也进行阻塞，最初线程完结运行。

两两数据交换

另外须要晓得是，Exchanger 只能用于两个线程之间的数据交换，一个线程开启数据交换之后，会阻塞直到其余任意线程同样开启数据交换达到替换点。

最初来个示例，开启 10 个线程，看它们是怎么两两替换的：

private static void test4() {Exchanger exchanger = new Exchanger();

    for (int i = 1; i <= 10; i++) {
        Integer data = i;
        new Thread(() -> {
            try {Object exchange = exchanger.exchange(data);
                System.out.println(Thread.currentThread().getName() + "-" + exchange);
            } catch (InterruptedException e) {e.printStackTrace();
            }
        }, "Java 技术栈" + i).start();}
}

输入后果：

能够看到，10 个线程，都两两替换彼此的数据了。

总结

本文介绍了线程之间的数据交换器 Exchanger 类的应用，只能用于多个线程中的两个线程两两替换数据，如果没有对应的线程替换就会始终阻塞，可设置超时，能够中断。

你都把握了吗？面试如果问到，你须要把握这个类的用法，当然也有其余的计划，但如果不是必须就没有必要反复造轮子，反复造轮子须要思考的面更多。

本文所有案例源代码曾经上传：

https://github.com/javastacks…

欢送 Star 学习，前面 Java 示例都会在这下面提供！

好了，明天的分享就到这里了，前面栈长会分享更多好玩的 Java 技术和最新的技术资讯，关注公众号 Java 技术栈第一工夫推送，我也将支流 Java 面试题和参考答案都整顿好了，在公众号后盾回复关键字 “ 面试 ” 进行刷题。

最初，感觉我的文章对你用播种的话，动动小手，给个在看、转发，原创不易，栈长须要你的激励。

版权申明： 本文系公众号 “Java 技术栈 ” 原创，转载、援用本文内容请注明出处，剽窃、洗稿一律投诉侵权，后果自负，并保留追究其法律责任的权力。

近期热文举荐：

1.1,000+ 道 Java 面试题及答案整顿(2022 最新版)

2. 劲爆！Java 协程要来了。。。

3.Spring Boot 2.x 教程，太全了！

4. 别再写满屏的爆爆爆炸类了，试试装璜器模式，这才是优雅的形式！！

5.《Java 开发手册（嵩山版）》最新公布，速速下载！

感觉不错，别忘了顺手点赞 + 转发哦！

退出移动版