（不谈废话，只有干货）解决线程间协做问题的工具类Exchanger详解

在好久以前我曾写过一篇一篇文章介绍线程间如何进行通讯的问题，当时使用的是等待通知模型，这篇文章介绍一个java提供的用于两个线程间通讯的工具类Exchanger。

1、概念理解

Exchanger的做用就是为了两个线程之间交换数据，他提供了一个内部方法exchange，这个内部方法就比如是一个同步点，只有两个方法都到达同步点，才能够交换数据。咱们换一张图来演示一波。

也就是说只有线程A和线程B都到达同步点，才能够交换数据。

咱们上代码直接看看如何使用，而后再去看看使用的时候须要注意什么。

2、使用案例

一、基本使用

首先咱们定义一个测试类ExchangerTest：

1public class ExchangerTest {
2    private static Exchanger<String> exchanger = new Exchanger<>();
3    private static String threadA_data = "100块";
4    private static String threadB_data = "50块";
5    public static void main(String[] args) {
6        new ThreadA(exchanger, threadA_data).start();
7        new ThreadB(exchanger, threadB_data).start();
8    }
9}

在这个类中，咱们使用了ThreadA和ThreadB两个线程交换数据，而后咱们定义了一个交换器Exchanger来交换。下面咱们看看这俩线程是如何实现的。

 1public class ThreadA extends Thread {
 2    private Exchanger<String> exchanger = new Exchanger<>();
 3    private String data = null;
 4    public ThreadA(Exchanger<String> exchanger, String data) {
 5        this.exchanger = exchanger;
 6        this.data = data;
 7    }
 8    @Override
 9    public void run() {
10        try {
11            TimeUnit.SECONDS.sleep(3);
12            System.out.println("线程A交换前的数据是："+data);
13            data = exchanger.exchange(data);
14            System.out.println("线程A交换后的数据是："+data);
15        } catch (InterruptedException e) {
16            e.printStackTrace();
17        }
18    }
19}

在这里咱们主要是看run方法的实现，首先咱们打印出交换以前的数据信息，而后使用交换器交换数据，最后再打印出交换以后的数据。因为ThreadB和ThreadA实现方式同样，在这里咱们只给出一份代码便可。下面咱们就能够运行一下，看看测试结果：

如今咱们看到，线程A和线程B就能够正常的进行交换了。经过这个案例咱们会发现，Exchanger使用起来真的是超级简单。不过看起来很简单，其实还挖了不少的坑，下面咱们来看看。

注意点一：两个线程最终必须到达同步点

这是什么意思呢？咱们画一张图，举一个例子。

上面这张图的意思是这个样子的，左边的线程还有20秒才能够到达同步点，可是右边的线程设置了超时时间，若是10秒钟后对方没有到达，那么此次交易就宣告失败。对于咱们的程序来讲也会出现异常。咱们代码演示一下：

首先此次咱们看右边的线程A：设置了超时时间为10秒

 1public class ThreadA extends Thread {
 2    private Exchanger<String> exchanger = new Exchanger<>();
 3    private String data = null;
 4    public ThreadA(Exchanger<String> exchanger, String data) {
 5        this.exchanger = exchanger;
 6        this.data = data;
 7    }
 8    @Override
 9    public void run() {
10        try {
11            TimeUnit.SECONDS.sleep(3);
12            System.out.println("线程A交换前的数据是："+data);
13            //线程A：设置超时时间为10秒，对应于右边的线程
14            data = exchanger.exchange(data,10,TimeUnit.SECONDS);
15            System.out.println("线程A交换后的数据是："+data);
16        } catch (InterruptedException | TimeoutException e) {
17            e.printStackTrace();
18        }
19    }
20}

而后就是左边的线程B：还须要20秒才能够抵达

 1public class ThreadB extends Thread {
 2    private Exchanger<String> exchanger = new Exchanger<>();
 3    private String data = null;
 4    public ThreadB(Exchanger<String> exchanger, String data) {
 5        this.exchanger = exchanger;
 6        this.data = data;
 7    }
 8    @Override
 9    public void run() {
10        try {
11            //我还有20秒才能够抵达
12            TimeUnit.SECONDS.sleep(20);
13            System.out.println("线程B交换后的数据hashcode是："+data.hashCode());
14            data = exchanger.exchange(data);
15            System.out.println("线程B交换后的数据hashcode是："+data.hashCode());
16        } catch (InterruptedException e) {
17            e.printStackTrace();
18        }
19    }
20}

如今咱们再去测试一下看看会出现什么结果：

咱们发现线程A等待了10秒以后，线程B尚未到达，那就宣告交易失败。程序出现超时异常。

注意点二：交换的线程必须成对出现

这个注意点是什么意思呢？其实就是不能是单，就比如是找对象，最后老是成双成对的，要是5个男的4个女的，那剩下的一个男同胞怎么办，只能在那傻等了。这个咱们也能够代码测试一下，只是新增了一个线程C。测试代码变一下：

 1public class ExchangerTest3 {
 2    private static Exchanger<String> exchanger = new Exchanger<>();
 3    private static String threadA_data = "100块";
 4    private static String threadB_data = "50块";
 5    private static String threadC_data = "10块";
 6    public static void main(String[] args) {
 7        new ThreadA(exchanger, threadA_data).start();
 8        new ThreadB(exchanger, threadB_data).start();
 9        new ThreadC(exchanger, threadC_data).start();
10    }
11}

此时咱们再去测试，就会发现，总有一个线程处于死循环一直等待的状态。

注意点三：多个线程交换数据

上面咱们提到了交换的线程配对以后不能落单，那么若是此时有多个成对的线程了，谁和谁配对呢？答案咱们先告诉你，那就是胡乱配对。

在这里咱们在注意点二的基础之上继续增长一个线程D，而后继续更改咱们的测试类运行一下：

对于Exchanger的使用基本上须要注意的就是这么多。但愿对你有帮助。