内容概要

Exchanger类的优点在于能够简洁高效地实现两个线程间的数据交换，通过Exchanger，开发者可以避免复杂的锁和同步机制，降低并发编程的难度，同时，它还提供了线程安全的数据交换保障，使得多线程协作更为可靠、易用性和高效性。

核心概念

举一个实际业务中的场景，假如，一个繁忙的火车站，有两列火车需要交换各自车厢里的货物，这两列火车来自不同的方向，载有不同的货物，但它们需要在同一个时间点、同一个地点进行交换，这时，火车站就充当了一个“中间站”的角色，确保两列火车能够准确无误地交换货物。

在上面场景中，Exchanger类就扮演了这样一个“中间站”的角色，它用于两个线程间的数据交换，这两个线程在某个点上需要互相交换各自的数据，就像那两列需要交换货物的火车。

Exchanger通常用来解决以下类似场景的问题，如下：

两个线程间需要交换数据的问题，在多线程编程中，经常会有这样的场景：两个线程各自持有一些数据，并且需要在某个点上交换这些数据，Exchanger类提供了一个简单、高效的机制来实现这种数据交换。

Exchanger类充当了一个数据交换的“中间站”，两个线程在需要交换数据时，会分别调用Exchanger的exchange()方法，并在该方法上阻塞等待，当两个线程都到达这个“中间站”时，Exchanger会负责将它们手中的数据进行交换，然后两个线程就可以继续各自的任务了。

好处是，它不需要额外的锁或同步机制来保证数据交换的正确性，Exchanger类内部已经实现了这些同步机制，使用起来非常简单方便，而且，由于Exchanger类是基于Java的并发包java.util.concurrent实现的，因此它具有很高的性能和可扩展性。

代码案例

下面是一个简单的Java代码示例，演示了如何使用Exchanger类来实现两个线程间的数据交换，如下代码：

import java.util.concurrent.Exchanger;  

public class ExchangerDemo {
   
     

    public static void main(String[] args) {
   
     
        // 创建一个Exchanger对象，用于交换数据  
        Exchanger<String> exchanger = new Exchanger<>();  

        // 创建并启动第一个线程，它将携带数据"Data from Thread 1"进行交换  
        Thread producer = new Thread(() -> {
   
     
            try {
   
     
                String producedData = "Data from Thread 1";  
                String consumerData = exchanger.exchange(producedData);  
                System.out.println("Thread 1 received: " + consumerData);  
            } catch (InterruptedException e) {
   
     
                Thread.currentThread().interrupt();  
                System.err.println("Thread 1 was interrupted");  
            }  
        });  

        // 创建并启动第二个线程，它将携带数据"Data from Thread 2"进行交换  
        Thread consumer = new Thread(() -> {
   
     
            try {
   
     
                String producedData = "Data from Thread 2";  
                // 为了让示例更清晰，让第二个线程稍微延迟一会儿，确保第一个线程先到达交换点  
                Thread.sleep(100);  
                String producerData = exchanger.exchange(producedData);  
                System.out.println("Thread 2 received: " + producerData);  
            } catch (InterruptedException e) {
   
     
                Thread.currentThread().interrupt();  
                System.err.println("Thread 2 was interrupted");  
            }  
        });  

        // 启动线程  
        producer.start();  
        consumer.start();  
    }  
}

在上面代码中，创建了一个Exchanger对象，并启动了两个线程，第一个线程（生产者线程）携带了一个字符串"Data from Thread 1"，并准备在exchanger.exchange(producedData)调用处等待交换，第二个线程（消费者线程）携带了另一个字符串"Data from Thread 2"，并在稍后的时间点也准备进行交换。

当两个线程都到达交换点时（即都调用了exchanger.exchange()方法），Exchanger类将负责交换它们手中的数据，然后，每个线程将继续执行，并打印出它从交换中获得的数据。

上述代码输出如下类似结果：

Thread 1 received: Data from Thread 2  
Thread 2 received: Data from Thread 1

核心API

Exchanger 类是 Java 并发包 java.util.concurrent 中的一个工具类，它提供了一个同步点，在这个点上，两个线程可以交换彼此的数据，它锁使用到的主要方法是 exchange(V x)，另外还有一个构造方法 Exchanger() 和一个不太常用的 exchange(V x, long timeout, TimeUnit unit) 方法，后者允许指定等待交换数据的超时时间。

以下是这些方法的详细说明：

1. 构造方法 Exchanger()创建一个新的 Exchanger，这个构造方法没有参数，创建的是一个泛型 Exchanger，可以在交换时接受任何类型的对象。

2. exchange(V x) 方法这个方法用于等待另一个线程到达此交换点（除非当前线程被中断），然后将给定的对象 x 交换给那个线程，并接收该线程的对象，通常，线程在调用此方法之前会先设置好要交换的数据。

   如果另一个线程在等待时到达，则此方法会立即返回那个线程的对象，如果没有其他线程等待，则此方法会一直等待，直到有线程到达交换点，或者当前线程被中断，如果当前线程在等待时被中断，则会抛出 InterruptedException。

3. exchange(V x, long timeout, TimeUnit unit) 方法这个方法与 exchange(V x) 类似，但增加了一个超时机制，它会等待指定的时间以进行交换，如果在指定的时间内没有线程到达交换点，则此方法会返回 null，参数 x 是要交换的对象，timeout 是等待的最长时间，unit 是时间单位（如 TimeUnit.SECONDS、TimeUnit.MILLISECONDS 等），这个方法也可能抛出 InterruptedException，如果当前线程在等待交换时被中断。

核心总结

Exchanger类是一个用于线程间交换数据的同步点，它提供了简洁的API，使得两个线程能够安全地交换彼此的对象，无需显式的锁或条件变量，此外，Exchanger的使用能够降低代码复杂性，提高可读性，使得并发编程更为直观。

Exchanger它仅限于两个线程之间的交换，对于涉及多个线程的数据交换场景则显得力不从心，此外，如果等待交换的线程被中断，Exchanger会抛出InterruptedException，需要开发者妥善处理中断情况。

END!
END!
END!

往期回顾

精品文章

Java并发基础：ConcurrentLinkedDeque全面解析！

Java并发基础：PriorityBlockingQueue全面解析！

Java并发基础：DelayQueue全面解析！

Java并发基础：LinkedBlockingDeque全面解析！

Java并发基础：LinkedTransferQueue全面解析！

精彩视频