可以在对中对元素进行配对和交换的线程的同步点。每个线程将条目上的某个方法呈现给 exchange 方法，与伙伴线程进行匹配，并且在返回时接收其伙伴的对象。Exchanger 可能被视为 SynchronousQueue 的双向形式。Exchanger 可能在应用程序（比如遗传算法和管道设计）中很有用。

内存一致性效果：对于通过 Exchanger 成功交换对象的每对线程，每个线程中在 exchange() 之前的操作 happen-before 从另一线程中相应的 exchange() 返回的后续操作。

public class ExchangerTest {
    private static  String steve=null;
    private static String tao=null;

    public void  a(Exchanger<String> exchanger){
        steve="steve";
        try {
            //把交换来的数据替换本身的数据
            System.out.println("steve ="+steve);
           steve= exchanger.exchange(steve);
            System.out.println("a 交换数据完成！时间："+System.currentTimeMillis());
            //等待模拟延迟和处理耗费的时间
            TimeUnit.SECONDS.sleep(1);
        } catch ( Exception e) {
            e.printStackTrace();
        }
    }
    public void  b(Exchanger<String> exchanger){
        tao="tao";
        try {
            //把交换来的数据替换本身的数据
            System.out.println("tao ="+tao);
           tao=exchanger.exchange(tao);
            System.out.println("b 交换数据完成！时间："+System.currentTimeMillis());
            TimeUnit.SECONDS.sleep(4);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        final Exchanger<String> exchanger=new Exchanger<>();
        final ExchangerTest test=new ExchangerTest();
       Thread t1= new Thread(new Runnable() {
            @Override
            public void run() {
                test.a(exchanger);
            }
        });
       Thread t2= new Thread(new Runnable() {
            @Override
            public void run() {
                test.b(exchanger);
            }
        });
       t1.start();
       t2.start();
       //等t1 t2线程执行结束，不然数据没有交换完毕
       while (t1.isAlive() || t2.isAlive() ){}

        System.out.println("steve :"+steve);
        System.out.println("tao :"+tao);
    }

}

这个工具类使用起来很简单，理解也不难。可以理解为两个人要进行交易，只能等大家都到了交易点，才能发生交易。所以上面的输出时间一定是一致的。下面是其API的方法，只有一个构造和两个方法。