SynchronousQueue------TransferStack源码分析

s，e在线程栈里面，TransferStack在堆里面，方法只是线程的执行逻辑。线程过来调用transfer方法，线程在堆里面创建一个节点，加到Stack里面去，然后这个线程归属节点的waiter，阻塞（方法局部变量保留）。配对的线程过来，在堆里创建一个节点加入stack，

配对后移除2个节点，正在配对时候，有线程带着局部变量e入队或者来交易，什么都不做只是帮助匹配（同时只能一个节点在配对），帮助配对完成之后，该入队就入队该交易就交易。

package com.itmayiedu;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;
import java.util.concurrent.locks.ReentrantLock;
import java.util.*;
import java.util.Spliterator;
import java.util.Spliterators;

public class SynchronousStack<E>   {
    abstract static class Transferer<E> {
        abstract E transfer(E e, boolean timed, long nanos);
    }
    static final int NCPUS = Runtime.getRuntime().availableProcessors();
    static final int maxTimedSpins = (NCPUS < 2) ? 0 : 32;
    static final int maxUntimedSpins = maxTimedSpins * 16;
    static final long spinForTimeoutThreshold = 1000L;

    static final class TransferStack<E> extends Transferer<E> {
        static final int REQUEST    = 0;//消费者 
        static final int DATA       = 1;//生产者 
        static final int FULFILLING = 2;//表示正在进行交易的节点。
        static boolean isFulfilling(int m) { return (m & FULFILLING) != 0; }//FULFILLING返回true,是否是正在进行交易的生产者或者消费者。
        static final class SNode {
            volatile SNode next;         
            volatile SNode match;       // 相匹配的节点
            volatile Thread waiter;      // 等待的线程
            //item域和mode域不需要使用volatile修饰，因为它们在volatile/atomic操作之前写，之后读
            Object item;                // item 域
            int mode;//  REQUEST,DATA,FULFILLING
            SNode(Object item) {
                this.item = item;
            }
            boolean casNext(SNode cmp, SNode val) {
                return cmp == next &&
                    UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);
            }
            boolean tryMatch(SNode s) {//匹配成功，则unpark等待线程
                if (match == null &&//设置本结点的匹配为s节点
                    UNSAFE.compareAndSwapObject(this, matchOffset, null, s)) {
                    Thread w = waiter;
                    if (w != null) {    // waiters need at most one unpark
                        waiter = null;
                        LockSupport.unpark(w);
                    }
                    return true;
                }
                return match == s;
            }
            void tryCancel() {//取消这个节点,match从原来的null变为this
                UNSAFE.compareAndSwapObject(this, matchOffset, null, this);
            }
            boolean isCancelled() {
                return match == this;
            }
            private static final sun.misc.Unsafe UNSAFE;
            private static final long matchOffset;
            private static final long nextOffset;
            static {
                try {
                    UNSAFE = getUnsafe();//sun.misc.Unsafe.getUnsafe();
                    Class<?> k = SNode.class;
                    matchOffset = UNSAFE.objectFieldOffset
                        (k.getDeclaredField("match"));
                    nextOffset = UNSAFE.objectFieldOffset
                        (k.getDeclaredField("next"));
                } catch (Exception e) {
                    throw new Error(e);
                }
            }
        }
        volatile SNode head;//栈的头结点 
        boolean casHead(SNode h, SNode nh) {
            return h == head &&
                UNSAFE.compareAndSwapObject(this, headOffset, h, nh);//改变头节点需要cas只有一个线程成功
        }
        static SNode snode(SNode s, Object e, SNode next, int mode) {//入账，新进来节点下一个节点是head节点。
            if (s == null) s = new SNode(e);
            s.mode = mode;
            s.next = next;
            return s;
        }

        E transfer(E e, boolean timed, long nanos) {
            SNode s = null;
            int mode = (e == null) ? REQUEST : DATA;//消费者是0生产者是1
            for (;;) {
                SNode h = head;//刚开始头节点为null，第一个进来的节点就是头节点。
                //入队2步：构建新节点新节点.next=原来头节点，原来头节点变为新节点。
                if (h == null || h.mode == mode) {  // 栈为空或者当前节点模式与头节点模式一样，将节点压入栈内，等待匹配
                    if (timed && nanos <= 0) {      // 新进来的入队节点已经超时，还要看一下头节点是否取消了？只有一个头节点，看下头节点。
                        if (h != null && h.isCancelled())// 节点被取消了，向前推进
                            casHead(h, h.next);    
                        else
                            return null;// 头节点没有被取消，但是这个节点已经超时，什么都不做，直接返回
                    } else if (casHead(h, s = snode(s, e, h, mode))) {//线程栈里面构建节点s，头节点指向最新进来的节点s，s.next=原来头节点
                        SNode m = awaitFulfill(s, timed, nanos);//  等待 匹配，线程阻塞时候局部变量保留，唤醒时候再次使用不变。
                        if (m == s) {  // 返回match到的节点m == s节点自己， 表示该节点被取消了或者超时、中断了
                            clean(s);
                            return null;
                        }
                        // 先唤醒在移除节点，唤醒之后这里执行，唤醒这里执行时候有可能还没有移除，这里就帮助移除。唤醒的是第一个生产节点s=62，此时head是交易节点81， h.next == s
                        if ((h = head) != null && h.next == s) 
                            casHead(h, s.next);// 将s.next节点设置为head，相当于取消节点h、s，帮助移除。
                        return (E) ((mode == REQUEST) ? m.item : s.item);
                    }
                // 取节点，头节点不是正在取节点的节点，头节点没有配对。
//取节点：线程过来调用transfer方法，线程在堆里面创建一个节点改变模式为FULFILLING，加到Stack里面去，然后配对，移除2个节点，返回值。
                } else if (!isFulfilling(h.mode)) { 
                    if (h.isCancelled())            // 取节点看头节点有没有取消
                        casHead(h, h.next);         // pop and retry
                    else if (casHead(h, s=snode(s, e, h, FULFILLING|mode))) {//消费者s进来也要入队成为头节点，将这个节点s的模式变为FULFILLING，s是交易节点，
                        for (;;) { // 比while效率高
                            SNode m = s.next;       //s是交易节点81，m是被匹配的节点62
                            if (m == null) {         // m == null，其他帮助配对的线程移除了
                                casHead(s, null);    // 将s弹出
                                s = null;           // 将s置空，下轮循环的时候还会新建，帮助GC
                                break;              // 退出该循环，继续主循环
                            }
                            SNode mn = m.next;
                            if (m.tryMatch(s)) {//s节点和m节点匹配，配对时候唤醒节点
                                casHead(s, mn);     // 匹配成功，将s 、 m弹出，完成交易之后将两个节点一起弹出，并且返回交易的数据。
                                return (E) ((mode == REQUEST) ? m.item : s.item);
                            } else                  // lost match
                                s.casNext(m, mn);   // 如果没有匹配成功，m有可能取消了，那么就需要把m从栈中移除。s继续跟mn做交易  没有人指向m就会被回收。
                        }
                    }
//如果栈顶已经存在一个模式为FULFILLING的节点，说明栈顶的节点正在进行匹配，那么就帮助这个栈顶节点快速完成交易，然后继续交易。
                } else { 
                    SNode m = h.next;    // h=81,m=62,h是交易节点，m是被配对节点，
                    if (m == null) // m == null ，执行到这一行时候，配对已经被别的帮助线程或者交易节点线程自己执行完了，
                        casHead(h, null);            
                    else {
                        SNode mn = m.next;//跟取节点差不多mn=56
                        if (m.tryMatch(h))    //62和81配对       
                            casHead(h, mn);         //帮助移除。h和m
                        else                       
                            h.casNext(m, mn);//帮助匹配失败，h的下一个节点变为下一个的下一个节点。  没有人指向m就会被回收。
                    }
                }
            }
        }
        SNode awaitFulfill(SNode s, boolean timed, long nanos) {
            final long deadline = timed ? System.nanoTime() + nanos : 0L;
            Thread w = Thread.currentThread();
            int spins = (shouldSpin(s) ?//第一个节点要自旋
                         (timed ? maxTimedSpins : maxUntimedSpins) : 0);
            for (;;) {
                if (w.isInterrupted())
                    s.tryCancel();
                SNode m = s.match; 
                if (m != null)
                    return m;//返回这个节点match到的节点
                if (timed) {
                    nanos = deadline - System.nanoTime();
                    if (nanos <= 0L) {
                        s.tryCancel();
                        continue;
                    }
                }
                if (spins > 0)
                    spins = shouldSpin(s) ? (spins-1) : 0;
                else if (s.waiter == null)
                    s.waiter = w; // establish waiter so can park next iter
                else if (!timed)
                    LockSupport.park(this);
                else if (nanos > spinForTimeoutThreshold)
                    LockSupport.parkNanos(this, nanos);
            }
        }
        boolean shouldSpin(SNode s) {//如果当前节点在栈顶，或者正在请求交易，那么就应该自旋。
            //因为很可能立刻就会有新的线程到来，那么就会立刻进行交易而不需要进行阻塞，然后被唤醒，这是需要过程的，所以这样的自旋等待是值得的。
            SNode h = head;
            boolean b = isFulfilling(h.mode);
            return (h == s || h == null || isFulfilling(h.mode));
        }
        void clean(SNode s) {//clean()方法就是将head节点到S节点之间所有已经取消的节点全部移出。
            s.item = null;   // forget item
            s.waiter = null; // forget thread
            SNode past = s.next;//s=39，past=38
            //这个方法首先找到接下来的第一个不为null并且没有被取消交易的节点past，然后设置新的head节点，
            if (past != null && past.isCancelled())
                past = past.next;
            SNode p;
            while ((p = head) != null && p != past && p.isCancelled())
                casHead(p, p.next);//p是从头节点开始第一个不移除的节点
            while (p != null && p != past) {//p到past之间的都要移除
                SNode n = p.next;
                if (n != null && n.isCancelled())
                    p.casNext(n, n.next);//移除节点n
                else
                    p = n;//修改p指针
            }
        }
        private static final sun.misc.Unsafe UNSAFE;
        private static final long headOffset;
        static {
            try {
                UNSAFE = getUnsafe();//sun.misc.Unsafe.getUnsafe();
                Class<?> k = TransferStack.class;
                headOffset = UNSAFE.objectFieldOffset
                    (k.getDeclaredField("head"));
            } catch (Exception e) {
                throw new Error(e);
            }
        }
    }
    private transient volatile Transferer<E> transferer;
    public SynchronousStack() {
        this(false);
    }
    public SynchronousStack(boolean fair) {
        transferer = fair ? new TransferStack<E>() : new TransferStack<E>();
    }
    public void put(E e) throws InterruptedException {
        if (e == null) throw new NullPointerException();
        if (transferer.transfer(e, false, 0) == null) {
            Thread.interrupted();
            throw new InterruptedException();
        }
    }
    public boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException {
        if (e == null) throw new NullPointerException();
        if (transferer.transfer(e, true, unit.toNanos(timeout)) != null)
            return true;
        if (!Thread.interrupted())
            return false;
        throw new InterruptedException();
    }

    public boolean offer(E e) {
        if (e == null) throw new NullPointerException();
        return transferer.transfer(e, true, 0) != null;
    }

    public E take() throws InterruptedException {
        E e = transferer.transfer(null, false, 0);
        if (e != null)
            return e;
        Thread.interrupted();
        throw new InterruptedException();
    }

    public E poll(long timeout, TimeUnit unit) throws InterruptedException {
        E e = transferer.transfer(null, true, unit.toNanos(timeout));
        if (e != null || !Thread.interrupted())
            return e;
        throw new InterruptedException();
    }

    public E poll() {
        return transferer.transfer(null, true, 0);
    } 
    
    private static sun.misc.Unsafe getUnsafe() {
        try {
            return sun.misc.Unsafe.getUnsafe();
        } catch (SecurityException tryReflectionInstead) {}
        try {
            return java.security.AccessController.doPrivileged
                    (new java.security.PrivilegedExceptionAction<sun.misc.Unsafe>() {
                        public sun.misc.Unsafe run() throws Exception {
                            Class<sun.misc.Unsafe> k = sun.misc.Unsafe.class;
                            for (java.lang.reflect.Field f : k.getDeclaredFields()) {
                                f.setAccessible(true);
                                Object x = f.get(null);
                                if (k.isInstance(x))
                                    return k.cast(x);
                            }
                            throw new NoSuchFieldError("the Unsafe");
                        }});
        } catch (java.security.PrivilegedActionException e) {
            throw new RuntimeException("Could not initialize intrinsics",
                    e.getCause());
        }
    }
}