并发新构件之Exchanger:交换器

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

我的理解就是：交换器类似于一个交易地点，先到的人（线程），等待后到的人，都到达后进行交易，等待时阻塞线程，交易后两个线程各自往下执行。

主要方法：exchange()

等待另一个线程到达此交换点（除非当前线程被中断），然后将给定的对象传送给该线程，并接收该线程的对象。
如果另一个线程已经在交换点等待，则出于线程调度目的，继续执行此线程，并接收当前线程传入的对象。当前线程立即返回，接收其他线程传递的交换对象。

之前

　　其他某个线程进入交换点；或者
　　其他某个线程中断当前线程。

如果当前线程：

在进入此方法时已经设置了该线程的中断状态；或者
在等待交换时被中断，

则抛出 InterruptedException，并且清除当前线程的已中断状态。

简单例子：

package com.houjun.current.newClassBank;

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

/**
 * @Author: HouJun
 * @Date: 2019/10/18 16:40
 * @Description: 交换器测试
 * @version: 1.0
 */
public class TestExchanger {
    public static void main(String[] args) throws InterruptedException {
        Exchanger<Integer> exchanger = new Exchanger<>();
        new Producer("", exchanger).start();//启动生产者线程
        new Consumer("", exchanger).start();//启动消费者线程
        TimeUnit.SECONDS.sleep(1);
    }

    static class Producer extends Thread {
        private Exchanger<Integer> exchanger;//交换器对象泛型为Integer
        private static int data = 0;

        Producer(String name, Exchanger<Integer> exchanger) {
            super("Producer-" + name);//调用父类构造方法
            this.exchanger = exchanger;//传入交换器对象
        }

        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                try {
                    TimeUnit.SECONDS.sleep(1);
                    data = i;
                    System.out.println(getName() + "交换前：" + data);
                    data = exchanger.exchange(data);//方法返回交换后的值
                    System.out.println(getName() + "交换后：" + data);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    static class Consumer extends Thread {
        private Exchanger<Integer> exchanger;
        private static int data = 0;

        Consumer(String name, Exchanger<Integer> exchanger) {
            super("Consumer-" + name);
            this.exchanger = exchanger;
        }

        @Override
        public void run() {
            while (true) {
                data = 0;
                System.out.println(getName() + "交换前：" + data);
                try {
                    TimeUnit.SECONDS.sleep(1);
                    data = exchanger.exchange(data);//方法返回交换后的值
                    System.out.println(getName() + "交换后：" + data);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}