exchanger java另一种栅栏

是另一种栅栏，它是一种两方two-party栅栏，各方在栅栏位置上交换数据。

当两方执行不对称的操作时，exchanger会非常有用。

场景例子：

当一个线程向缓冲区写入数据，而另一个线程从缓冲区中读取数据。这些线程可以使用Exchanger来汇合，并将满的缓冲区与空的缓冲区交换。当两个线程通过Exchanger交换对象时，这种交换就把这两个对象安全地发布给另一方。

数据交换的时机取决于应用程序的相应需求。最简单的方案是当缓冲区被填满时，由填充任务进行交换，当缓冲区为空时，由清空任务进行交换。这样会把需要交换的次数降至最低，但如果新数据的到达率不可预测，那么一些数据的处理过程就将延迟。另一个方法是不仅当缓冲被填满时进行交换，并且当缓冲被填充到一定程度并保持一定时间后，也进行交换。

例子：

package com.citi.test.mutiplethread.demo5;

import java.util.concurrent.Exchanger;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExchangerTest {
    public static void main(String[] args) {
        ExecutorService executor=Executors.newCachedThreadPool();
        final Exchanger exchanger=new Exchanger();
        executor.execute(new Runnable() {
            String data1="Ling";
            @Override
            public void run() {
                doExchangerWork(data1, exchanger);
            }
        });
        executor.execute(new Runnable() {
            String data1="huhx";
            @Override
            public void run() {
                doExchangerWork(data1, exchanger);
            }
        });
        executor.shutdown();
    }
    private static void doExchangerWork(String data1,Exchanger exchanger){
        try {
            System.out.println(Thread.currentThread().getName()+" 正在把数据"+data1+"交换出去");
            Thread.sleep((long)(Math.random()*1000));
            
            String data2=(String)exchanger.exchange(data1);
            System.out.println(Thread.currentThread().getName()+" 交换数据到"+data2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

如果我们一直买东西，而不邮寄东西，那么Exchanger类其实就变成了简化版本的生产者和消费者的模型。快递员就是生产者，我们本身就是消费者，而柜子就成为了我们媒介容器，看下面的一个例子：

package com.citi.test.mutiplethread.demo5;

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

public class ExchangerTest1 {
    private static Exchanger<DataBuffer<Integer>> exchanger=new Exchanger<>();
    static DataBuffer<Integer> initialEmptyBuffer=new DataBuffer<Integer>();
    static DataBuffer<Integer> initialFullBuffer=new DataBuffer<Integer>();
    static AtomicInteger countDown=new AtomicInteger(5);
    static class ProducerWorker implements Runnable{
        long sleep;
        public ProducerWorker(long sleep) {
            this.sleep=sleep;
        }
        @Override
        public void run() {
            DataBuffer<Integer> currentBuffer=initialEmptyBuffer;
            while(currentBuffer!=null&&countDown.get()>0){
                try {
                    TimeUnit.SECONDS.sleep(sleep);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                currentBuffer.put(countDown.get());//每次放入数据
                if(currentBuffer.isFull()){
                    try {
                        System.out.println(Thread.currentThread().getName()+" 放入了快递"+countDown.get());
                        currentBuffer=exchanger.exchange(currentBuffer);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }//交换后得到null
                }
                countDown.getAndDecrement();
            }
        }
    }
    
    static class ConsumerWorker implements Runnable{
        long sleep;
        public ConsumerWorker(long sleep) {
            this.sleep=sleep;
        }
        @Override
        public void run() {
            DataBuffer<Integer> currentBuffer=initialFullBuffer;
            while(currentBuffer!=null&&countDown.get()>0){
                try {
                    TimeUnit.SECONDS.sleep(sleep);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                //如果为空就进行交换
                if(currentBuffer.isEmpty()){
                    try {
                        currentBuffer=exchanger.exchange(currentBuffer);//交换数据
                        Integer value=currentBuffer.get();
                        System.out.println(Thread.currentThread().getName()+" 拿走了快递"+value);
                        System.out.println();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    public static void main(String[] args) {
        new Thread(new ProducerWorker(1),"快递员").start();
        new Thread(new ConsumerWorker(3),"我      ").start();
    }
    
    private static class DataBuffer<T>{
        T data;
        public boolean isFull(){
            return data!=null;
        }
        public boolean isEmpty(){
            return data==null;
        }
        public T get(){
            T d=data;
            data=null;
            return d;
        }
        public void put(T data){
            this.data=data;
        }
    }
}

下面是主要的内部类，属性和方法。

/**
 * Nodes hold partially exchanged data.  This class
 * opportunistically subclasses AtomicReference to represent the
 * hole.  So get() returns hole, and compareAndSet CAS'es value
 * into hole.  This class cannot be parameterized as "V" because
 * of the use of non-V CANCEL sentinels.
 
    Node 持有部分交换数据。这个类继承AtomicReference适时地代表那个洞。
    所以get()返回洞，并且用CAS来将值填充进洞。
    
 
 */
private static final class Node extends AtomicReference<Object> {
    /** The element offered by the Thread creating this node. */
    public final Object item;

    /** The Thread waiting to be signalled; null until waiting. */
    public volatile Thread waiter;

    /**
     * Creates node with given item and empty hole.
     * @param item the item
     */
    public Node(Object item) {
        this.item = item;
    }
}

/**
 * A Slot is an AtomicReference with heuristic padding to lessen
 * cache effects of this heavily CAS'ed location.  While the
 * padding adds noticeable space, all slots are created only on
 * demand, and there will be more than one of them only when it
 * would improve throughput more than enough to outweigh using
 * extra space.
 */
private static final class Slot extends AtomicReference<Object> {
    // Improve likelihood of isolation on <= 64 byte cache lines
    long q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, qa, qb, qc, qd, qe;
}

/**
 * Main exchange function, handling the different policy variants.
 * Uses Object, not "V" as argument and return value to simplify
 * handling of sentinel values.  Callers from public methods decode
 * and cast accordingly.
 *
 * @param item the (non-null) item to exchange
 * @param timed true if the wait is timed
 * @param nanos if timed, the maximum wait time
 * @return the other thread's item, or CANCEL if interrupted or timed out
 */
private Object doExchange(Object item, boolean timed, long nanos) {
    Node me = new Node(item);                 // Create in case occupying
    int index = hashIndex();                  // Index of current slot
    int fails = 0;                            // Number of CAS failures

    for (;;) {
        Object y;                             // Contents of current slot
        Slot slot = arena[index];
        if (slot == null)                     // Lazily initialize slots
            createSlot(index);                // Continue loop to reread
        else if ((y = slot.get()) != null &&  // Try to fulfill
                 slot.compareAndSet(y, null)) {
            Node you = (Node)y;               // Transfer item
            if (you.compareAndSet(null, item)) {
                LockSupport.unpark(you.waiter);
                return you.item;
            }                                 // Else cancelled; continue
        }
        else if (y == null &&                 // Try to occupy
                 slot.compareAndSet(null, me)) {
            if (index == 0)                   // Blocking wait for slot 0
                return timed ?
                    awaitNanos(me, slot, nanos) :
                    await(me, slot);
            Object v = spinWait(me, slot);    // Spin wait for non-0
            if (v != CANCEL)
                return v;
            me = new Node(item);              // Throw away cancelled node
            int m = max.get();
            if (m > (index >>>= 1))           // Decrease index
                max.compareAndSet(m, m - 1);  // Maybe shrink table
        }
        else if (++fails > 1) {               // Allow 2 fails on 1st slot
            int m = max.get();
            if (fails > 3 && m < FULL && max.compareAndSet(m, m + 1))
                index = m + 1;                // Grow on 3rd failed slot
            else if (--index < 0)
                index = m;                    // Circularly traverse
        }
    }
}

底层原理分析：

用到的关键技术是

1.使用CAS自旋来进行数据交换。

2.使用LockSupport的park方法使交换线程进入休眠等待，用unpartk方法使线程唤醒。

3.此外还声明了一个Node对象来存储交换数据，该类继承了AtomicReference.

使用exchanger可以轻松的实现两个线程交换数据。如果超过两个线程，很可能会有问题。

参考资料：

https://cloud.tencent.com/developer/article/1350850