并发工具：Exchanger工具

1 Exchanger工具介绍

Exchanger（交换器），从字面意思来看它的主要作用就是用于交换，Exchanger简化了两个线程之间的数据交互，并且提供了两个线程之间的数据交换点，Exchanger等待两个线程调用其exchange()方法。调用此方法时，交换机会交换两个线程提供给对方的数据。

2 一对线程间的数据交换

Exchanger在某种程度上可以看成是生产者和消费者模式的实现，但是它重点关注的是数据交换，所谓交换就是我给了你A，你会给我B，而生产者消费者模式中间使用队列将其解耦。生产者只需要在队列中放入元素，它并不在乎是否会有消费者的存在，同样消费者也只是从队列中获取元素，并不关心生产者是否存在

2.1 Demo1

定义两个线程T1和T2，分别调用Exchanger的exchange方法将各自的数据传递给对方，在这里需要注意的是，每个线程在构造数据时的开销是不一样的，因此调用方法exchange的时机并不是同一时刻，当T1线程在执行exchange方法的时候，如果T2方法没有执行exchange方法，那么T1线程会进入阻塞状态等待T2线程执行exchange方法，只有当两个线程都执行了exchange方法之后，它们才会退出阻塞。

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

/**
 * @author wyaoyao
 * @date 2021/4/20 14:54
 */
public class ExchangerExample1 {
    public static void main(String[] args) {
        // 定义Exchanger类，该类是一个泛型类，String类型标明一对线程交换的数据只能是String类型
        Exchanger<String> exchanger = new Exchanger<>();
        // 定义线程T1
        Thread t1 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " start...");
            try {
                // 随机休眠1～10秒钟
                TimeUnit.SECONDS.sleep(ThreadLocalRandom.current().nextInt(10));
                // 执行exchange方法，将对应的数据传递给T2线程，同时从T2线程获取交换的数据
                // 返回值是T2线程中返回的数据
                String dataFromT2 = exchanger.exchange("data from T1");
                System.out.println(Thread.currentThread().getName() + " received: " + dataFromT2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " end...");
        }, "T1");
        // 定义线程T1
        Thread t2 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " start...");
            try {
                // 随机休眠1～10秒钟
                TimeUnit.SECONDS.sleep(ThreadLocalRandom.current().nextInt(10));
                // 执行exchange方法，将对应的数据传递给T2线程，同时从T2线程获取交换的数据
                // 返回值是T1线程中返回的数据
                String dataFromT1 = exchanger.exchange("data from T2");
                System.out.println(Thread.currentThread().getName() + " received: " + dataFromT1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " end...");
        }, "T2");

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

输出：

T1 start...
T2 start...
T2 received: data from T1
T2 end...
T1 received: data from T2
T1 end...

Exchanger的exchange方法，该方法是一个阻塞方法，只有成对的线程执行了exchange调用之后才会退出阻塞，
调用exchange方法需要传递交换的数据，该数据的类型在定义Exchanger时就已经确立了，同时exchange方法的返回值代表着对方线程所交换过来的内容

到这应该也就知道和生产者消费者的区别了，生产者和消费者互相不知道对方的存在，而这两个的存在是知道，只有双方互相交换了数据，才会退出阻塞。

2.2 Demo2

如果我们只希望一个线程生成数据，另外一个线程处理数据。也就是说其中A线程会用到B线程交换过来的数据，而B线程压根不会用到（忽略）A线程交换过来的数据，该怎么做呢？

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

/**
 * @author wyaoyao
 * @date 2021/4/20 14:54
 */
public class ExchangerExample2 {
    public static void main(String[] args) throws InterruptedException {
        // 定义数据类型为String的Exchanger
        final Exchanger<String> exchanger = new Exchanger<>();
        // 定义StringGenerator 线程，并将该线程命名为Generator
        StringProducer producer =
                new StringProducer("Producer",exchanger);
        // 定义StringConsumer 线程，并将该线程命名为Consumer
        StringConsumer consumer =
                new StringConsumer("Consumer",exchanger);
        // 分别启动线程
        consumer.start();
        producer.start();

        // 休眠1分钟后，将Generator和Consumer线程关闭
        TimeUnit.MINUTES.sleep(1);
        consumer.close();
        producer.close();
    }

    interface Closable {
        /**
         * 关闭方法
         */
        void close();

        /**
         * 判断当前线程是否被关闭
         * true: 关闭
         */
        boolean closed();
    }

    static abstract class ClosableThread extends Thread implements Closable {
        // 使用string模拟交换的数据类型
        protected final Exchanger<String> exchanger;

        private volatile boolean closed = false;

        private ClosableThread(String name, Exchanger<String> exchanger) {
            super(name);
            this.exchanger = exchanger;
        }

        @Override
        public void run() {
            // 判断当前线程是否关闭
            while (!closed) {
                // 没有关闭，就执行doExchange
                this.doExchange();
            }
        }

        /**
         * 核心交换逻辑实现
         */
        protected abstract void doExchange();


        @Override
        public void close() {
            System.out.println(this.getName() + " will be closed");
            this.closed = true;
            this.interrupt();
        }

        @Override
        public boolean closed() {
            return this.closed || this.isInterrupted();
        }
    }

    static class StringProducer extends ClosableThread {
        private char initialChar = 'A';

        public StringProducer(String name, Exchanger<String> exchanger) {
            super(name, exchanger);
        }

        @Override
        protected void doExchange() {
            // 模拟复杂的数据生成过程
            String str = "";
            for (int i = 0; i < 3; i++) {
                // 模拟耗时
                try {
                    TimeUnit.SECONDS.sleep(ThreadLocalRandom.current().nextInt(5));
                } catch (InterruptedException e) {
                    // ignore
                }
                str += (initialChar++);
            }
            System.out.println(Thread.currentThread().getName() + " produce data is " + str);
            try {
                //  如果当前线程未关闭，则执行Exchanger的exchange方法
                if (!this.closed()) {
                    exchanger.exchange(str);
                }
            } catch (InterruptedException e) {
                // 如果closed()方法之后执行了close方法，那么执行中断操作时此处会捕获到中断信号
                System.out.println(currentThread() + "received the close signal.");
            }
        }
    }

    private static class StringConsumer extends ClosableThread {


        private StringConsumer(String name, Exchanger<String> exchanger) {
            super(name, exchanger);
        }


        @Override
        protected void doExchange() {
            try {
                // 如果当前线程未关闭，则执行Exchanger的exchange方法
                // Consumer线程直接使用null值作为exchange的数据对象
                if (!this.closed()) {
                    String data = exchanger.exchange(null);
                    System.out.println(currentThread().getName() + " received the data: " + data);
                }
            } catch (InterruptedException e) {
                System.out.println(currentThread().getName() + " received the close signal.");
            }
        }
    }
}

• Producer线程虽然进行了数据交换，但是它并不关心另外一个Consumer线程所交换过来的数据，
• 同样在Consumer线程直接使用null值作为exchange的数据对象

数据输出：

Producer produce data is ABC
Consumer received the data: ABC
Producer produce data is DEF
Consumer received the data: DEF
Producer produce data is GHI
Consumer received the data: GHI
Producer produce data is JKL
Consumer received the data: JKL
Producer produce data is MNO
Consumer received the data: MNO
Producer produce data is PQR
Consumer received the data: PQR
Producer produce data is STU
Consumer received the data: STU
Producer produce data is VWX
Consumer received the data: VWX
Consumer will be closed
Producer will be closed
Consumer received the close signal.
Producer produce data is YZ[

3 Exchanger的方法详解

3.1 API介绍

Exchanger对外提供的方法非常简单，仅有两个方法：

/**
数据交换方法，该方法的作用是将数据x交换至搭档线程，
执行该方法后，当前线程会进入阻塞状态，
只有当搭档线程也执行了exchange方法之后，该当前线程才会退出阻塞状态进行下一步的工作，
与此同时，该方法的返回值代表着搭档线程所传递过来的交换数据。
**/
public V exchange(V x) throws InterruptedException;
/**
增加了超时的功能，也就是说在指定的时间内搭档线程没有执行exchange方法，当前线程会退出阻塞，并且返回值为null。
**/
public V exchange(V x, long timeout, TimeUnit unit) throws InterruptedException, TimeoutException

Exchanger用于数据交换的前提基本上是exchange方法被成对调用。另外，我们虽然可以在exchange方法中传入null值，但是Exchanger会为我们提供一个默认的Object（NULL_ITEM）值，在最后返回值时会根据交换数据与NULL_ITEM进行匹配，并将交换数据重新返回为null：

 private static final Object NULL_ITEM = new Object();
 public V exchange(V x) throws InterruptedException {
     Object v;
     // 如果x为null，则使用NULL_ITEM替代，NULL_ITEM其实就是一个new object
     Object item = (x == null) ? NULL_ITEM : x; // translate null args
     if ((arena != null ||
          (v = slotExchange(item, false, 0L)) == null) &&
         ((Thread.interrupted() || // disambiguates null return
           (v = arenaExchange(item, false, 0L)) == null)))
         throw new InterruptedException();
         // 匹配v值，如果v值与NULL_ITEM相等，则说明对方线程交换了null值，因此重新还原为null
     return (v == NULL_ITEM) ? null : (V)v;
 }

3.2 打断Exchange的阻塞

注意：如果使用Exchanger的两个线程，其中一个由于某种原因意外退出，那么此时另外一个线程将会永远处于阻塞状态，进而导致JVM进程出现假死的情况。当然使用了超时功能的exchange在设定时间到达时会退出阻塞

public static void main(String[] args) {
    Exchanger<String> exchanger = new Exchanger<>();
    new Thread(() ->{
        try {
            // 线程进入阻塞
            exchanger.exchange(null);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    },"T1").start();
}

上面这段代码，没有另一个线程调用exchange方法，所以就会导致T1永远阻塞下去。

那么如何让这个线程退出阻塞呢？exchange方法会抛出InterruptedException异常，也就是说可以通过捕获这个异常进行退出：

public static void main(String[] args) throws InterruptedException {
     Exchanger<String> exchanger = new Exchanger<>();
     Thread thread = new Thread(() -> {
         try {
             // 线程进入阻塞
             exchanger.exchange(null);
         } catch (InterruptedException e) {
             System.out.println(Thread.currentThread().getName() + " 捕获到 Interrupted 信号");
         }
     }, "T1");

     thread.start();
     // 1s 后打断T1
     TimeUnit.SECONDS.sleep(1);
     thread.interrupt();
 }

上面的程序片段会将执行了exchange方法的线程从阻塞中中断。

但是需要注意的是：如果线程执行单元中还存在其他可中断的阻塞方法呢，比如sleep

public static void main(String[] args) throws InterruptedException {
    Exchanger<String> exchanger = new Exchanger<>();
    Thread thread = new Thread(() -> {
        try {
            // 模拟线程执行某些可捕获中断信号的方法，比如sleep方法
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            System.out.println(Thread.currentThread().getName() + " sleep 捕获到 Interrupted 信号");
        }
        try {
            // 线程进入阻塞
            exchanger.exchange(null);
        } catch (InterruptedException e) {
            System.out.println(Thread.currentThread().getName() + " 捕获到 Interrupted 信号");
        }
    }, "T1");

    thread.start();
    // 1s 后打断T1
    TimeUnit.SECONDS.sleep(1);
    thread.interrupt();
}

线程t将永远不会被中断，原因是在线程t的休眠代码块中捕获到了中断信号并未做任何处理，因此中断信号被擦除。当线程再次进入exchange方法时就会进入阻塞，因此该线程将会导致JVM出现假死的情况。

也就是说如果当前线程被执行过中断方法，并且从未捕获过中断信号，那么在执行exchange方法的时候会立即被中断