源码分析之JUC-Exchanger

Exchanger是一种线程间安全交换数据的机制。当线程A调用Exchange对象的exchange()方法后，他会进入阻塞状态，直到线程B也调用了exchange()方法，然后以线程安全的方式交换数据，之后线程A和B继续运行。
这里先提出两个疑问，带着疑问我们分析一下源码：

1. 可不可以多个线程之间进行数据交换？
2. 两个线程交换的数据是不是必须类型一致呢？

调试进去，你会发现Exchanger的主要逻辑实现在方法doExchange里面。

    private Object doExchange(Object item, boolean timed, long nanos) {        Node me = new Node(item);                 // Create in case occupying        /**         * index是线程ID的hash值映射到0到max之间的一个值,         * max的定义如下：可知其默认值为0，也就是说index的初始值为0         *     private final AtomicInteger max = new AtomicInteger();         *              */        int index = hashIndex();                  // Index of current slot        int fails = 0;                            // Number of CAS failures        /**         * 这里的无条件的for循环用于自旋         */        for (;;) {            Object y;                             // Contents of current slot            /**             * arena是一个Slot数组，初始化语句如下：这里取index=0即第一个元素             *     private static final int CAPACITY = 32;             *     private volatile Slot[] arena = new Slot[CAPACITY];             */            Slot slot = arena[index];            /**             * 判断slot是否为null，初始状态arena[0]肯定为null，也就是说初始状态，程序会进入该分支             * 调用createSlot方法创建slot，并赋值给arena的index位置的元素。然后会进入下次循环。             *              */            if (slot == null)                     // Lazily initialize slots                createSlot(index);                // Continue loop to reread            /**             * 判断slot的值否为null，在非null的情况下（说明该槽里有值，即有其他线程等待交换），然后             * 通过CAS尝试取出该值并把slot（因为slot是AtomicReference类型，值就是其成员value的             * 值）原值赋值为null，CAS操作成功后，当前slot就被释放了，其他线程可以继续使用这个             * slot，当前两个线程通过Node进行交换值。             */            else if ((y = slot.get()) != null &&  // Try to fulfill                     slot.compareAndSet(y, null)) {                Node you = (Node)y;               // Transfer item                /**                 * 这里通过CAS交换当前slot对应的两个线程（实际上一个slot同时只能有一个线程占据，这                 * 里的意思是一个线程刚好遇到当前slot的值不为null，即有线程等待交换）的值，如果成功                 * 则返回交换后的值（这里注意返回的是you.item, you是Node类型，Node是                 * AtomicReference类型，you.compareAndSet(null, item)这句代码的作用是CAS替换                 * 为null的value值，详情可参考AtomicReference的方法compareAndSet），这一点要特                 * 别注意（否则后面的代码很难看懂，特别是spinWait）：等待交换的线程把要交换的数据保                 * 存在item成员里，而交换线程把要交换的数据保存在value里面；并unpark                 * 唤醒交换线程；如果失败（被其他线程抢先了），继续下面的判断，这时如果运气好，坑还没                 * 被占（当前slot），则在下一个if分支有机会占坑（只是有机会，运气不好也有可能失                 * 败）。                 */                if (you.compareAndSet(null, item)) {                    LockSupport.unpark(you.waiter);                    return you.item;                }                                 // Else cancelled; continue            }            /**             * 判断当前slot的值y是否为null（即是否有线程占据改slot），如果为null（即没有线程占             * 据），则通过CAS把自己的值赋给当前slot（即尝试占据当前slot），如果CAS操作成功，判断             * 当前索引是否0，如果为0（即说明当前线程所在的slot是整个slot数组的第一个元素），则阻塞             * 等待（timed标示阻塞是否有超时，nanos是阻塞时间）；如果CAS操作失败（即当前slot被其他             * 线程占据），             */            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);                /**                 * 所谓的spin wait：就是固定次数循环（详情参考方法spinWait），不同于awaitNanos。                 */                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();                /**                 * 如果spinWait自旋返回CANCEL（即线程没有得到交换的数据被取消，两种可能：一种是被取                 * 消，一种是达到自旋次数还未得到交换数据），判断当前最大索引值是否大于当前索引的一半                 * 是则把slot数组的最大下标值做减一操作（就好比市场摊位太多，商贩和消费者碰头的概率太                 * 低，减少摊位数，增大这个概率）。                 */                if (m > (index >>>= 1))           // Decrease index                    max.compareAndSet(m, m - 1);  // Maybe shrink table            }            /**             * 每个槽上允许2次失败             */            else if (++fails > 1) {               // Allow 2 fails on 1st slot                int m = max.get();                /**                 * CAS失败处理达到3次则增大index，也就是增加CAS的槽的下标（就好比商贩A在市场的当前                 * 这个摊位半天没遇到一位顾客，那他肯定觉得这个摊位不发财，要换摊位）。                 */                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            }        }    }

    private static Object spinWait(Node node, Slot slot) {      /**        * private static final int SPINS = (NCPU == 1) ? 0 : 2000;        * NCPU 表示CPU的核数，        * 所谓的spin wait：就是固定次数循环，每次计数减一对于单核系统来说，spin wait        * 是不做的，因为单核做wait时需要占用CPU，其他线程是无法使用CPU，因此这样的等待        * 毫无意义。而多核系统中spin值为2000，也就是会做2000次循环。如果循环完成后依然        * 没得到交换的数据，那么会返回一个CANCEL对象表示请求依旧被取消，并且把Node从        * slot中清除。详情参考spinWait方法。        */        int spins = SPINS;        for (;;) {            /**             * 这里需要注意，node.get()返回值是Node（AtomicReference类型）的value，一定要与Node             * 的item区分开，当交换线程来到之前，等待交换的线程自旋获取Node的value，直到value不为             * 空（即交换线程到来并交换了数据，在方法doExchange的第二个if分支中交换线程通过             * you.compareAndSet(null, item)，把自己的交换数据item赋值给为null的value）。             */            Object v = node.get();            if (v != null)                return v;            else if (spins > 0)                --spins;            else                tryCancel(node, slot);        }    }