《java.util.concurrent 包源码阅读》18 Exchanger

Exchanger可以看做双向数据传输的SynchronousQueue，即没有生产者和消费者之分，任意两个线程都可以交换数据。

在JDK5中Exchanger被设计成一个容量为1的容器，存放一个等待线程，直到有另外线程到来就会发生数据交换，然后清空容器，等到下一个到来的线程。

从JDK6开始，Exchanger用了类似ConcurrentMap的分段思想，提供了多个slot，增加了并发执行时的吞吐量。

Exchanger不存在公平不公平的模式，因为没有排队的情况发生，只要有两个线程就可以发生数据交换。

直接看核心方法：

    private Object doExchange(Object item, boolean timed, long nanos) {
        Node me = new Node(item);
        // index是线程ID的hash值映射到0到max之间的一个值
        // 一般情况下max为0，这样线程交换数据只会使用第一个slot，
        // 即index是0，而max不为0情况请看下面的循环
        int index = hashIndex();

        // CAS操作失败的次数
        int fails = 0;

        for (;;) {
            // 当前slot中存储的对象，也就是Node
            Object y;
            Slot slot = arena[index];
            // 延迟加载，即只有当slot为null时才创建一个slot
            // 延迟加载后重新循环一次
            if (slot == null)
                createSlot(index);
            // slot中有数据，也就意味着有线程在等待交换数据
            // 这时可以尝试用CAS重置slot(把slot存储的对象设为null)
            // 用slot中存储的对象和当前线程进行数据交换
            // 如果交换成功就通知原先等待的线程
            else if ((y = slot.get()) != null &&
                     slot.compareAndSet(y, null)) {
                Node you = (Node)y;
                if (you.compareAndSet(null, item)) {
                    LockSupport.unpark(you.waiter);
                    return you.item;
                }
                // 如果slot存储的对象已经被重置为null，但是数据交换失败了
                // 这时就意味着这个等待的线程的交换请求被取消了
                // 在分析wait类型的方法代码时会看到如何处理这种情况
            }
            // 如果slot中没有存储对象，那么首先尝试把当前线程存储到slot中
            // 如果存储失败了，就重新循环
            else if (y == null &&
                     slot.compareAndSet(null, me)) {
                // index为0意味着仅仅有当前线程在等待交换数据,因此直接等待即可
                if (index == 0)
                    return timed ?
                        awaitNanos(me, slot, nanos) :
                        await(me, slot);
                // 所谓的spin wait：就是固定次数循环，每次计数减一
                // 对于单核系统来说，spin wait是不做的，因为单核
                // 做wait时需要占用CPU，其他线程是无法使用CPU，因此这样
                // 的等待毫无意义。而多核系统中spin值为2000，也就是会做
                // 2000次循环。
                // 如果循环完成后依然没有得到交换的数据，那么会返回一个
                // CANCEL对象表示请求依旧被取消，并且把Node从slot中清除
                Object v = spinWait(me, slot);
                if (v != CANCEL)
                    return v;
                // 如果取消了，就新建一个Node取消原先取消的Node用于下次循环
                me = new Node(item);
                int m = max.get();
                // index除2，缩小slot的范围
                // 同时如果m过大，减小m
                if (m > (index >>>= 1))
                    max.compareAndSet(m, m - 1);
            }
            // 允许CAS失败两次，因为两个else if中都有CAS，因此这里
            // 允许两个else if的CAS操作都失败过
            else if (++fails > 1) {
                int m = max.get();
                // 失败超过3次，增大m，并且从m处重新索引
                if (fails > 3 && m < FULL && max.compareAndSet(m, m + 1))
                    index = m + 1;
                // 当index小于0，回到m，重新循环
                else if (--index < 0)
                    index = m;
            }
        }
    }

 

这篇文章关于索引index这块弄得不是很清楚，后续会继续研究，及时更新。

转载于:https://www.cnblogs.com/wanly3643/p/3939552.html