【JAVA核心知识】17.2：线程间通信协作-Exchanger

JDK1.5提供了用于两个线程间通信协作的工具类Exchanger。通过Exchanger可以在两个线程之间进行数据交换，且需要两个线程都到达交换节点时才开始进行数据交换，否则先到达交换节点的线程会处于等待状态等待另一个线程执行交换动作。
Exchanger定义为Exchanger<V>,V为泛型，为期望交换的数据类型，Exchanger是一个很简单的类：

• Exchanger()：构造方法
• V exchange(V x)：执行交换动作，入参为要发送的数据，返回为接到的交换数据。如果执行时没有其他线程处于交换等待状态，则阻塞等待其他线程到达交换节点。
• V exchange(V x, long timeout, TimeUnit unit)：和V exchange(V x)功能类似，不同的是带有最大等待时间，超过最大等待时间则抛出异常TimeoutException。因此调用此方法要求捕获TimeoutException进行等待超时的处理。超时之后交换动作即终结，下一个到达交换节点的线程需要继续等待需要其他线程的交换动作。

示例：

package thread.exchange;

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

public class ExchanerDemo {

    public static void main(String[] args) {

        final Exchanger<String> ec = new Exchanger<>();

        Runnable r1 = new Runnable() {

            @Override
            public void run() {
                try {
                    System.out.println("r1 start");
                    System.out.println("r1 exchange start");
                    System.out.println("r1 get:" + ec.exchange("r1 to other")); // r1交换数据
                    System.out.println("r1 exchange end");
                } catch (InterruptedException e) {
                    System.out.println("r1 exchange exception");
                    e.printStackTrace();
                }
            }
        };

        Runnable r2 = new Runnable() {

            @Override
            public void run() {
                try {
                    System.out.println("r2 start");
                    Thread.sleep(100); // 等待保证r1先进入交换状态
                    System.out.println("r2 exchange start");
                    System.out.println("r2 get:" + ec.exchange("r2 to other")); // r2进行交货
                    System.out.println("r2 exchange end");
                } catch (InterruptedException e) {
                    System.out.println("r2 exchange exception");
                    e.printStackTrace();
                }
            }
        };

        Runnable r3 = new Runnable() {

            @Override
            public void run() {
                try {
                    System.out.println("r3 start");
                    Thread.sleep(200); // 等待保证r1和r2已完成数据交货
                    System.out.println("r3 exchange start");
                    try {
                        // 没有后续其它线程和这个线程交换,会报超时异常
                        System.out.println("r3 get:" + ec.exchange("r3 to other", 100, TimeUnit.MILLISECONDS));
                    } catch (TimeoutException e) {
                        System.out.println("r3 exchange Timeout");
                        e.printStackTrace();
                    }
                    System.out.println("r3 exchange end");
                } catch (InterruptedException e) {
                    System.out.println("r3 exchange exception");
                    e.printStackTrace();
                }
            }
        };
        new Thread(r1).start();
        new Thread(r2).start();
        new Thread(r3).start();

    }
}

执行结果：

r1 start
r1 exchange start
r3 start
r2 start
r2 exchange start
r2 get:r1 to other
r2 exchange end
r1 get:r2 to other
r1 exchange end
r3 exchange start
r3 exchange Timeout
java.util.concurrent.TimeoutException
	at java.util.concurrent.Exchanger.exchange(Exchanger.java:626)
	at thread.exchange.ExchanerDemo$3.run(ExchanerDemo.java:56)
	at java.lang.Thread.run(Thread.java:748)
r3 exchange end

PS：
【JAVA核心知识】系列导航 [持续更新中…]
上篇导航：17.1：线程间变量共享
下篇导航：18：线程本地变量-ThreadLocal
欢迎关注…