并发编程之Exchanger(交换者)浅析

---

一、简介

Exchanger 是 Java 并发包中的一个工具类，用于在两个线程之间交换数据。它提供了一个同步点，当两个线程都到达这个同步点时，它们可以交换彼此的数据。

特点：

• 工作原理：Exchanger 提供了一个同步点，当两个线程都调用 exchange() 方法时，它们会被阻塞，直到另一个线程也调用了 exchange() 方法。然后，Exchanger 会交换两个线程传递给 exchange() 方法的数据，并让两个线程继续执行。
• 线程间数据交换：Exchanger 主要用于在线程间交换数据。两个线程可以在 Exchanger 中交换彼此的数据，这对于协作和通信非常有用。
• 应用场景：Exchanger 可以用于解决生产者-消费者问题，线程间数据传递，以及一些需要线程间协作的场景。例如，一个线程负责生产数据，另一个线程负责消费数据，在它们之间使用 Exchanger 进行数据交换。
• 特性：Exchanger 是一种线程间同步的机制，可以确保两个线程在同一个同步点上交换数据。它是一种简单而有效的线程协作工具。
• 使用方法：使用 Exchanger 需要两个线程共同协作。每个线程在需要交换数据时调用 exchange() 方法，并将要交换的数据传递给该方法。当两个线程都调用了 exchange() 方法后，它们会交换数据并继续执行。

---

二、API

• Exchanger() 构造方法：
  Exchanger()：创建一个新的 Exchanger 对象，用于线程间数据交换。
• exchange(V x) 方法：
  V exchange(V x) throws InterruptedException：将当前线程的数据 x 与另一个线程交换，并返回另一个线程传递过来的数据。如果另一个线程还没有调用 exchange() 方法，则当前线程会被阻塞，直到另一个线程也调用了 exchange() 方法。如果线程在等待过程中被中断，则会抛出 InterruptedException 异常。
• exchange(V x, long timeout, TimeUnit unit) 方法：
  V exchange(V x, long timeout, TimeUnit unit) throws InterruptedException, TimeoutException：与上述方法类似，但是可以设置超时时间，如果在指定的时间内另一个线程还没有调用 exchange() 方法，则会抛出 TimeoutException 异常。
• toString() 方法：
  String toString()：返回 Exchanger 对象的字符串表示形式，通常包括类名和哈希码值。

三、使用

3.1 demo1

小红和小明进行正常交易

    public static void test1() {
        Exchanger<String> exchanger = new Exchanger<>();
        Thread ming = new Thread(() -> {
            try {
                String mingData = "商品A";
                System.out.println("小明有：" + mingData);
                String redData = exchanger.exchange(mingData);
                System.out.println("小明收到：" + redData);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread hong = new Thread(() -> {
            try {
                String hongData = "商品B";
                System.out.println("小红有：" + hongData);
                String mingData = exchanger.exchange(hongData);
                System.out.println("小红收到：" + mingData);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        ming.start();
        hong.start();
    }

输出：交换成功

3.2 demo2

此时暗恋小红的小刚看不惯了，以为他俩在进行不正常交易，他也要凑进来交易

    public static void test1() {
        Exchanger<String> exchanger = new Exchanger<>();
        Thread ming = new Thread(() -> {
            try {
                String mingData = "商品A";
                System.out.println("小明有：" + mingData);
                String hongData = exchanger.exchange(mingData);
                System.out.println("小明收到：" + hongData);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread hong = new Thread(() -> {
            try {
                String hongData = "商品B";
                System.out.println("小红有：" + hongData);
                String mingData = exchanger.exchange(hongData);
                System.out.println("小红收到：" + mingData);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread gang = new Thread(() -> {
            try {
                String gangData = "商品C";
                System.out.println("小刚有：" + gangData);
                String elseData = exchanger.exchange(gangData);
                System.out.println("小刚收到：" + elseData);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        ming.start();
        hong.start();
        gang.start();
    }

输出：小刚替代小红和小明进行了交易，导致小红没有进行交易。小刚你要干什么？！

结论：上述代码可以看到，使用Exchanger，三个(奇数)线程会导致其中一个没有交换成功。

3.3 demo3

暗恋小明的小花发现他们多人交易，鼓起勇气也插进队伍来进行交易

 public static void test1() {
        Exchanger<String> exchanger = new Exchanger<>();
        Thread ming = new Thread(() -> {
            try {
                String mingData = "小明的商品A";
                System.out.println("小明有：" + mingData);
                String hongData = exchanger.exchange(mingData);
                System.out.println("小明收到：" + hongData);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread hong = new Thread(() -> {
            try {
                String hongData = "小红的商品B";
                System.out.println("小红有：" + hongData);
                String mingData = exchanger.exchange(hongData);
                System.out.println("小红收到：" + mingData);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread gang = new Thread(() -> {
            try {
                String gangData = "小刚的商品C";
                System.out.println("小刚有：" + gangData);
                String elseData = exchanger.exchange(gangData);
                System.out.println("小刚收到：" + elseData);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread hua = new Thread(() -> {
            try {
                String huaData = "小花的商品D";
                System.out.println("小花有：" + huaData);
                String elseData = exchanger.exchange(huaData);
                System.out.println("小花收到：" + elseData);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        ming.start();
        hong.start();
        gang.start();
        hua.start();
    }       

输出：有情人终成眷属！

正经点：

Exchanger 类通常是用于成对线程之间的数据交换。在使用 Exchanger 进行数据交换时，通常需要两个线程同时调用 exchange() 方法来进行数据交换。每个线程都会等待另一个线程到达交换点，然后彼此交换数据。

四、应用场景

Exchanger 类适用于需要两个线程之间进行数据交换的场景：

• 协同工作：当两个线程需要协同工作，并且彼此需要交换数据时，可以使用 Exchanger 来实现数据的安全交换。
• 生产者-消费者模式：在生产者-消费者模式中，生产者线程生成数据，消费者线程消费数据。通过 Exchanger，生产者和消费者线程可以安全地交换数据。
• 数据校验：在某些情况下，两个线程各自生成一部分数据，然后需要对彼此生成的数据进行校验。Exchanger 可以用来交换数据并进行校验。
• 并行计算：在并行计算中，不同线程可能需要共享计算结果或中间数据。Exchanger 可以用来在不同线程之间传递计算结果。
• 任务分配：在任务分配场景中，主线程可能需要将任务分配给不同的工作线程，并等待工作线程完成任务后再继续执行。Exchanger 可以用来在主线程和工作线程之间进行任务分配和结果交换。