Exchanger 线程数据交换器

最新推荐文章于 2024-03-23 13:35:33 发布

程序员的暴击

最新推荐文章于 2024-03-23 13:35:33 发布

阅读量5.6k

点赞数

分类专栏： JUC 文章标签： java 并发工具 Exchanger Juc 并发编程

本文链接：https://blog.csdn.net/weixin_49561445/article/details/120598363

版权

JUC 专栏收录该内容

17 篇文章 4 订阅

订阅专栏

基本结构

Exchanger——交换器，是JDK1.5时引入的一个同步器，主要作用是交换数据。

Exchanger有点类似于CyclicBarrier， CyclicBarrier是一个栅栏，到达栅栏的线程需要等待其它一定数量的线程到达后，才能通过栅栏。可以看成是一个双向栅栏

在这里插入图片描述
Thread1线程到达栅栏后，会首先观察有没其它线程已经到达栅栏，如果没有就会等待，如果已经有其它线程（Thread2）已经到达了，就会以成对的方式交换各自携带的信息，因此Exchanger非常适合用于两个线程之间的数据交换。

public class ExchangerTest {

    public static void main(String[] args) {
        Exchanger<Integer> exchanger = new Exchanger<>();

        for (int i = 0; i < 4; i++) {

            new Thread(new Prodcucer("producer", exchanger,i),"Pro"+i).start();

            new Thread(new Consumer("consumer", exchanger,3-i),"Con"+i).start();

        }
        
    }
}

class Prodcucer implements Runnable {

    private final Exchanger<Integer> exchanger;
    private final String name;
    private final int item;


    Prodcucer(String name, Exchanger<Integer> exchanger,int item) {

        this.exchanger = exchanger;
        this.name = name;
        this.item = item;

    }

    @Override
    public  void run() {

        synchronized (Prodcucer.class){
            try {
                TimeUnit.SECONDS.sleep(1);
                System.out.println(name+" 交换前:" + item);
                int data = exchanger.exchange(item);
                System.out.println(name+" 交换后:" + data);
            } catch (InterruptedException s) {
                s.printStackTrace();
            }

        }

    }
}
class  Consumer implements Runnable {
    private final Exchanger<Integer> exchanger;
    private final String name;
    private final int item;


    Consumer(String name, Exchanger<Integer> exchanger, int item) {
        this.name = name;
        this.exchanger = exchanger;
        this.item = item;
    }

    @Override
    public void run() {
       synchronized (Consumer.class){
           System.out.println(name+" 交换前:" + item);
           try {
               TimeUnit.SECONDS.sleep(2);
               int data = exchanger.exchange(item);
               System.out.println(name+" 交换后:" + data);
           } catch (InterruptedException d) {
               d.printStackTrace();
           }

       }
    }
}

构造器

构造时，内部创建了一个Participant对象，Participant是Exchanger的一个内部类，本质就是一个 ThreadLocal用来保存线程本地变量

Node

public Exchanger() {
    participant = new Participant();
}

static final class Participant extends ThreadLocal<Node> {
        public Node initialValue() { return new Node(); }
}

//Node表示每个线程自身的数据交换结点
static final class Node {
        //以下字段,多槽交换时使用
        int index;              // 多槽数组的索引
        int bound;              // 记录上次的 bound（多槽位下槽位数组中索引出现的最大值）
        int collides;           // 当前 bound下CA5失败的次数
        int hash;               // 线程的随机数,用于自旋优化
        Object item;            //当前线程携带的数据(先到达的线程会将自己携带的数据赋值到item上)
        volatile Object match;  //配对线程携带的数据(后到达的线程会将自身携带的值设置到配对线程的该字段上)
        volatile Thread parked; //此结点上的阻塞线程(先到达并阻塞的线程会设置该值为自身)
    }

内部的静态变量


   
 
    //用于多槽位交换中设置任意两个之间被使用的插槽索引间距,避免缓存伪共享
   
    private static final int ASHIFT = 5;

//槽位数组的最大支持的索引，最大允许的数组长度为MMASK+1，要小于2^26,通常情况255（0xff）的上限足以达到多槽位算法的预期扩容限制。
    private static final int MMASK = 0xff;

 
   //绑定属性bound的序列/版本号的单位，每一次成功改变bound均会增加SEQ值，通常情况最大为256
    private static final int SEQ = MMASK + 1;

    //系统cpu的核数，为了自旋和扩容操作使用
    private static final int NCPU = Runtime.getRuntime().availableProcessors();

 
    //槽位数组的索引最大值：slots的值原则上保证所有线程不出现竞争，或者大多数情况下索引出现的最大值
    static final int FULL = (NCPU >= (MMASK << 1)) ? MMASK : NCPU >>> 1;
 
    //等待另一个线程的交换信息的到达，迭代的实际数平均约为此值的两倍(2048):注意：单核CPU禁用
    private static final int SPINS = 1 << 10;
 
   //表示传入方法的参数无效(或者作为函数返回时返回值无效的判定)：exchange API的交换数据必须存在，禁止传入null参数
    private static final Object NULL_ITEM = new Object();

   
    // 内部 exchane 方法 设置超时   超时 返回的空对象值
    private static final Object TIMED_OUT = new Object();

Exchanger有两种数据交换的方式，当并发量低的时候，内部采用“单槽位交换”；并发量高的时候会采用“多槽位交换

public V exchange(V x) throws InterruptedException {
        Object v;
        Node[] a;
        Object item = (x == null) ? NULL_ITEM : x; // 如果交换数据为null的话可以看到交换的是空对象
         /*
         这里的判断用来决定数据交换方式:
         1.单槽交換:当多槽交换数组为空时( arena=null),进行单槽交换( slotexchange)
         2.多槽交換:当多槽交换数组不为空( arena!=nul),或单槽交换失败时返回了null,进行多槽交换( arenaexchange)
         
         */
        if (((a = arena) != null ||
             (v = slotExchange(item, false, 0L)) == null) &&
            (Thread.interrupted() || // disambiguates null return
             (v = arenaExchange(item, false, 0L)) == null))
            throw new InterruptedException();
        return (v == NULL_ITEM) ? null : (V)v;
    }

exchange其实就是一个用于判断数据交换方式的方法，它的内部会根据Exchanger的某些字段状态来判断当前应该采用单槽交换（slotExchange）还是多槽交换（arenaExchange）

在这里插入图片描述
Exchanger的arena字段是一个Node类型的数组，代表了一个槽数组，只在多槽交换时会用到。此外，Exchanger还有一个slot字段，表示单槽交换结点，只在单槽交换时使用。

slot字段最终会指向首个到达的线程的自身Node结点，表示线程占用了槽位

 private volatile Node[] arena;//多槽交换数组

    /**
     * Slot used until contention detected.
     */
    private volatile Node slot;//单槽交换节点

单槽交换

在这里插入图片描述
slotExchange单槽交换方法

/**
 * 单槽交换 :slotExchange的入参item表示当前线程携带的数据，返回值正常情况下为配对线程携带的数据
 *
 * @param item 待交换的数据
 * @return 其它配对线程的数据; 如果多槽交换被激活或被中断返回null, 如果超时返回TIMED_OUT(一个Obejct对象)
 */
 
private final Object slotExchange(Object item, boolean timed, long ns) {
    // 获取当前线程node对象
    Node p = participant.get();
    // 当前线程
    Thread t = Thread.currentThread();
    // 若果线程被中断，就直接返回null
    if (t.isInterrupted()) // preserve interrupt status so caller can recheck
        return null;
	// 自旋
    for (Node q;;) {
        // 保存slot的引用
        if ((q = slot) != null) {
             // slot 不为null，即表示已有线程已经把需要交换的数据设置在slot中了,当前线程以最后到达栅栏
			// 通过CAS将slot设置成null
            if (SLOT.compareAndSwapObject(this, SLOT, q, null)) {
                // CAS操作成功后，将slot中的item赋值给对象v，以便返回。
                // 这里也是就读取之前线程要交换的数据
                Object v = q.item;
                // 将当前线程需要交给的数据设置在q中的match
                q.match = item;
                 // 获取被挂起的线程
                Thread w = q.parked;//获取被挂起的线程(先到达的线程)，solt不为空则说明q的线程先到达
                if (w != null)
                    // 如果线程不为null，唤醒它
                    LockSupport.unpark(w);
                // 返回其他线程给的V
                return v;
            }
            // create arena on contention, but continue until slot null
            // CAS 操作失败，表示有其它线程竞争，在此线程之前将数据已取走
            // NCPU:CPU的核数
            // bound == 0 表示arena数组未初始化过，CAS操作bound将其增加SEQ
            //CPU核数数多于1个, 且bound为0时创建arena数组，并将bound设置为SEQ大小
            if (NCPU > 1 && bound == 0 &&
                BOUND.compareAndSwapInt(this, BOUND, 0, SEQ))
                // 初始化arena数组
                arena = new Node[(FULL + 2) << ASHIFT];
        }
        // 只有当arena不为空才会执行slotExchange方法的
		// 所以表示刚好已有其它线程加入进来将arena初始化
        else if (arena != null)
            // 这里就需要去执行arenaExchange
            return null; // caller must reroute to arenaExchange
        else {
            // 这里表示当前线程是以第一个线程进来交换数据
            // 或者表示之前的数据交换已进行完毕，这里可以看作是第一个线程
            // 将需要交换的数据先存放在当前线程变量p中
            p.item = item;
            // 将需要交换的数据通过CAS设置到交换区slot
            if (SLOT.compareAndSwapObject(this, SLOT, null, p))
                // 交换成功后跳出自旋
                break;
            // CAS操作失败，表示有其它线程刚好先于当前线程将数据设置到交换区slot
            // 将当前线程变量中的item设置为null，然后自旋获取其它线程存放在交换区slot的数据
            p.item = null;
        }
    }

    // await release
    // 执行到这里表示当前线程已将需要的交换的数据放置于交换区slot中了，
    // 等待其它线程交换数据然后唤醒当前线程
    int h = p.hash;
    long end = timed ? System.nanoTime() + ns : 0 L;
    // 自旋次数多核是1024，单核是1
    int spins = (NCPU > 1) ? SPINS : 1;
    Object v;
    // 自旋等待直到p.match不为null，也就是说等待其它线程将需要交换的数据放置于交换区slot
    while ((v = p.match) == null) {
        // 下面的逻辑主要是自旋等待，直到spins递减到0为止，多核的话可能会自旋1024次
        if (spins > 0) {
            h 0= h << 1;
            h ^= h >>> 3;
            h ^= h << 10;
            if (h == 0)//第一次自旋肯定为0
                h = SPINS | (int) t.getId();//spins和自己的线程id异或操作
            else if (h < 0 && (--spins & ((SPINS >>> 1) - 1)) == 0)
                Thread.yield();
        } else if (slot != p)//优化操作:配对线程已经到达, 但是还未完全准备好, 所以需要再自旋等待一会儿
            spins = SPINS;
        // 此处表示未设置超时或者时间未超时
        else if (!t.isInterrupted() && arena == null &&
            (!timed || (ns = end - System.nanoTime()) > 0 L)) {//已经自旋很久了, 还是等不到配对, 此时才阻塞当前线程
           
            // 给p挂机线程的值赋值
            p.parked = t;
            if (slot == p){
                   // 如果slot还没有被置为null，也就表示暂未有线程过来交换数据，需要将当前线程挂起
                 if (ns == 0L)
                        LockSupport.park(this);
                    else
                        LockSupport.parkNanos(this, ns);
           }
            // 线程被唤醒，将被挂起的线程设置为null
            p.parked = null;
         
        // 不是以上条件时(可能是arena已不为null或者超时)    
        } else if (SLOT.compareAndSwapObject(this, SLOT, p, null)) {
             // arena不为null则v为null,其它为超时则v为超时对象TIMED_OUT，并且跳出循环
            v = timed && ns <= 0 L && !t.isInterrupted() ? TIMED_OUT : null;
            break;
        }
    }
    // 取走match值，并将p中的match置为null
    MATCH.setRelease(p, null);
    // 设置item为null
    p.item = null;
    p.hash = h;
    // 返回交换值
    return v;
}

在这里插入图片描述

如果当前线程是首个到达的线程，会将slot字段指向自身的Node结点，表示槽位被占用；
然后，线程会自旋一段时间，如果经过一段时间的自旋还是等不到配对线程到达，就会进入阻塞。（这里之所以不直接阻塞，而是自旋，是出于线程上下文切换开销的考虑，属于一种优化手段）

稍后到达的配对线程：

如果当前线程（配对线程）不是首个到达的线程，则到达时槽（slot）已经被占用，此时slot指向首个到达线程自身的Node结点。配对线程会将slot置空，并取Node中的item作为交换得到的数据返回，另外，配对线程会把自身携带的数据存入Node的match字段中，并唤醒Node.parked所指向的线程（也就是先到达的线程）。

首先到达的线程被唤醒：

线程被唤醒后，由于match不为空（存放了配对线程携带过来的数据），所以会退出自旋，然后将match对应的值返回

多槽位交换

在单槽交换中，同时出现了多个配对线程竞争修改slot槽位，导致某个线程CAS修改slot失败时，就会初始化arena多槽数组，后续所有的交换都会走arenaExchange

/**
 * 多槽交换
 *
 * @param item 待交换的数据
 * @return 其它配对线程的数据; 如果被中断返回null, 如果超时返回TIMED_OUT(一个Obejct对象)
 */
// timed 为true表示设置了超时时间，ns为>0的值，反之没有设置超时时间
private final Object arenaExchange(Object item, boolean timed, long ns) {
    Node[] a = arena;
    // 获取当前线程中的存放的node
    Node p = participant.get();
    //index初始值0
    for (int i = p.index;;) { // access slot at i
        // 遍历，如果在数组中找到数据则直接交换并唤醒线程，如未找到则将需要交换给其它线程的数据放置于数组中
        int b, m, c;
        //ASHIFT 设置插槽间的间距使槽位数据位于不同缓存行中，避免刷新缓存
        int j = (i << ASHIFT) + ((1 << ASHIFT) - 1);
            if (j < 0 || j >= alen)
                j = alen - 1;
        // 其实这里就是向右遍历数组，只是用到了元素在内存偏移的偏移量
        // q实际为arena数组偏移地址位上的node
        Node q = (Node)AA.getAcquire(a, j);
        // 如果q不为null，并且CAS操作成功，将下标j的元素置为null；AA 为数组的方法句柄
        if (q != null && AA.compareAndSet(a, j, q, null)) {
            // 表示当前线程已发现有交换的数据，然后获取数据，唤醒等待的线程
            Object v = q.item; // release
            q.match = item;
            Thread w = q.parked;
            if (w != null)
                LockSupport.unpark(w);
            return v;
        // q 为null 并且 i 未超过数组边界，并将当前数组位置赋值给m    
        } else if (i <= (m = (b = bound) & MMASK) && q == null) {
             // 将需要给其它线程的item赋予给p中的item
            p.item = item; // offer
            //将数组里的对应下标位置赋值为p
            if (AA.compareAndSet(a, j, null, p)) {
                // 交换成功
                long end = (timed && m == 0) ? System.nanoTime() + ns : 0 L;
                Thread t = Thread.currentThread(); // wait
                // 自旋直到有其它线程进入，遍历到该元素并与其交换，同时当前线程被唤醒
                for (int h = p.hash, spins = SPINS;;) {
                    Object v = p.match;
                    if (v != null) {
                        // 其它线程设置的需要交换的数据match不为null
                        // 将match设置null,item设置为null
                        MATCH.setRelease(p, null);
                        p.item = null; // clear for next use
                        p.hash = h;
                        return v;
                    } else if (spins > 0) {
                        h ^= h << 1;
                        h ^= h >>> 3;
                        h ^= h << 10; // xorshift
                        if (h == 0) // initialize hash
                            h = SPINS | (int) t.getId();
                        else if (h < 0 && // 50%的几率true
                            (--spins & ((SPINS >>> 1) - 1)) == 0)
                            Thread.yield(); // wait前先进行2此yield
                    } else if (AA.getAcquire(a, j) != p)//配对线程已经到达, 但是还未完全准备好, 所以需要再自旋等待一会 
                        // 和slotExchange方法中的类似，arena数组中的数据已被CAS设置
                       // match值还未设置，让其再自旋等待match被设置
                        spins = SPINS; // releaser hasn't set match yet
                    else if (!t.isInterrupted() && m == 0 &&
                        (!timed ||
                            (ns = end - System.nanoTime()) > 0 L)) {
                      
                         // 线程t赋值
                        p.parked = t; // minimize window
                        
                        if (AA.getAcquire(a, j) == p){
                             // 数组中对象还相等，表示线程还未被唤醒，唤醒线程
                             if (ns == 0L)
                                    LockSupport.park(this);
                                else
                                    LockSupport.parkNanos(this, ns);
                       }   
                        p.parked = null;
                          
                     //插槽数据没有其他线程改变，将查找节点置为null成功
                    } else if (AA.getAcquire(a, j) == p &&
                         AA.compareAndSet(a, j, p, null)) {
                    
                        if (m != 0) // 尝试缩容
                            BOUND.compareAndSet(this, BOUND, b, b + SEQ - 1);
                        p.item = null;
                        p.hash = h;
                        i = p.index >>>= 1; // 缩容一倍 
                        if (Thread.interrupted())
                            return null;
                        if (timed && m == 0 && ns <= 0 L)
                            return TIMED_OUT;
                        break; // expired; restart
                    }
                }
            } else
                // 交换失败，表示有其它线程更改了arena数组中下标i的元素
                p.item = null; // clear offer
        } else {
            // 此时表示下标不在bound & MMASK或q不为null但CAS操作失败，无效槽位位置, 需要扩容
           // 需要更新bound变化后的值
            if (p.bound != b) { // stale; reset
                p.bound = b;
                p.collides = 0;
                // 反向遍历
                i = (i != m || m == 0) ? m : m - 1;
            } else if ((c = p.collides) < m || m == FULL ||
                !BOUND.compareAndSet(this, BOUND, b, b + SEQ + 1)) {
                 // 记录CAS失败的次数
                p.collides = c + 1;
                // 循环遍历
                i = (i == 0) ? m : i - 1; // cyclically traverse
            } else
                // 此时表示bound值增加了SEQ+1
                i = m + 1; // grow
            // 设置下标
            p.index = i;
        }
    }
}


static {
        try {
            //MethodHandle.Lookup可以通过相应的findxxx方法得到相应的方法句柄，类似于反射
            //方法句柄是对底层方法、构造函数、字段或类似低级操作的类型化、直接可执行的引用，具有参数或返回值的可选转换。这些转换非常普遍，包括转换、插入、删除和替换等模式;MethodHandle 要比反射快很多因为访问检查在创建的时候就已经完成了，而不是像反射一样等到运行时候才检查.MethodHandles可以操作方法，更改方法参数的类型和他们的顺序。而反射则没有这些功能。
          //反射更通用，但是安全性更差，因为可以在不授权的情况下使用反射对象。而method Handles遵从了分享者的能力。所以method handle是一种更低级的发现，适配和调用方法的方式，唯一的优点就是更快。所以反射更适合主流Java开发者，而method handle更适用于对编译和运行性能有要求的人,适合做底层开发  
            MethodHandles.Lookup l = MethodHandles.lookup();
            BOUND = l.findVarHandle(Exchanger.class, "bound", int.class);
            SLOT = l.findVarHandle(Exchanger.class, "slot", Node.class);
            MATCH = l.findVarHandle(Node.class, "match", Object.class);
            AA = MethodHandles.arrayElementVarHandle(Node[].class);
        } catch (ReflectiveOperationException e) {
            throw new ExceptionInInitializerError(e);
        }
    }

多槽交换方法arenaExchange的整体流程和slotExchange类似，主要区别在于它会根据当前线程的数据携带结点Node中的index字段计算出命中的槽位。

如果槽位被占用，说明已经有线程先到了，之后的处理和slotExchange一样；

如果槽位有效且为null，说明当前线程是先到的，就占用槽位，然后按照：spin->yield->block这种锁升级的顺序进行优化的等待，等不到配对线程就会进入阻塞。

在定位arena数组的有效槽位时，需要考虑缓存行的影响。由于高速缓存与内存之间是以缓存行为单位交换数据的，根据局部性原理，相邻地址空间的数据会被加载到高速缓存的同一个数据块上（缓存行），而数组是连续的（逻辑，涉及到虚拟内存）内存地址空间，因此，多个slot会被加载到同一个缓存行上，当一个slot改变时，会导致这个slot所在的缓存行上所有的数据（包括其他的slot）无效，需要从内存重新加载，影响性能。

exchange通过使用ASHIFT 来设置槽位之间的间距使槽位数据位于不同缓存行中，避免缓存失效强制从主内存刷新导致性能降低的情况出现

总结：

Exchanger的数据交换内部实现策略支持两个线程情况下的单槽位交换，以及多线程情况下的多槽位交换，在多槽位交换过程中，每个线程最终会和哪一个线程交换是不能确定的，它只能保证能够两两成功交换。单槽位交换很简单，当线程来交换数据的时候，如果发现槽位为空，则以spin + yield + block的方式进行等待，否则就和占据槽位的线程进行交换，然后唤醒等待的线程拿着数据返回。多槽交换方法arenaExchange会根据当前线程的数据携带结点Node中的index字段计算出命中的槽位。

SynchronousQueue对比

SynchronousQueue线程A通过SynchronousQueue将数据a交给线程B；线程A通过Exchanger和线程B交换数据，线程A把数据a交给线程B，同时线程B把数据b交给线程A。可见，SynchronousQueue是交给一个数据，Exchanger是交换两个数据

程序员的暴击

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Exchanger 线程数据交换器

基本结构Exchanger——交换器，是JDK1.5时引入的一个同步器，主要作用是交换数据。Exchanger有点类似于CyclicBarrier， CyclicBarrier是一个栅栏，到达栅栏的线程需要等待其它一定数量的线程到达后，才能通过栅栏。可以看成是一个双向栅栏Thread1线程到达栅栏后，会首先观察有没其它线程已经到达栅栏，如果没有就会等待，如果已经有其它线程（Thread2）已经到达了，就会以成对的方式交换各自携带的信息，因此Exchanger非常适合用于两个线程之间的数据交换。
复制链接

扫一扫