同步队列_非公平模式_TransferStack

非公平模式_TransferStack（栈实现LIFO）

工作原理

非公平模式实现的同步队列

    /** Dual stack */
    /**
     * 非公平模式实现的同步队列，内部数据结构是 “栈”
     */
    static final class TransferStack<E> extends Transferer<E> {
                /** 表示Node类型为 请求类型 */
        static final int REQUEST    = 0;
        /** Node represents an unfulfilled producer */
        /** 表示Node类型为 数据类型 */
        static final int DATA       = 1;
        /** Node is fulfilling another unfulfilled DATA or REQUEST */
        /** 表示Node类型为 匹配中类型
         * 假设栈顶元素为 REQUEST-NODE，当前请求类型为 DATA的话，入栈会修改类型为 FULFILLING 【栈顶 & 栈顶之下的一个node】。
         * 假设栈顶元素为 DATA-NODE，当前请求类型为 REQUEST的话，入栈会修改类型为 FULFILLING 【栈顶 & 栈顶之下的一个node】。
         */
        static final int FULFILLING = 2;

        /** Returns true if m has fulfilling bit set. */
        //判断当前模式是否为 匹配中状态。
        static boolean isFulfilling(int m) { return (m & FULFILLING) != 0; }

       //判断当前模式是否为 匹配中状态。
        static boolean isFulfilling(int m) { return (m & FULFILLING) != 0; }

TransferStacks中的节点

       static final class SNode {
            //指向下一个栈帧
            volatile SNode next;        // next node in stack
            //与当前node匹配的节点
            volatile SNode match;       // the node matched to this
            //假设当前node对应的线程 自旋期间未被匹配成功，那么node对应的线程需要挂起，挂起前 waiter 保存对应的线程引用，
            //方便 匹配成功后，被唤醒。
            volatile Thread waiter;     // to control park/unpark
            //数据域，data不为空 表示当前Node对应的请求类型为 DATA类型。 反之则表示Node为 REQUEST类型。
            Object item;                // data; or null for REQUESTs
            //表示当前Node的模式 【DATA/REQUEST/FULFILLING】
            int mode;
           
           
           
            //CAS方式设置Node对象的next字段。
            boolean casNext(SNode cmp, SNode val) {
                //优化：cmp == next  为什么要判断？
                //因为cas指令 在平台执行时，同一时刻只能有一个cas指令被执行。
                //有了java层面的这一次判断，可以提升一部分性能。 cmp == next 不相等，就没必要走 cas指令。
                return cmp == next &&
                    UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);
            }
           
           
                        *
             /* 尝试匹配
             * 调用tryMatch的对象是 栈顶节点的下一个节点，与栈顶匹配的节点。
             *
             * @return ture 匹配成功。 否则匹配失败..
             */
            boolean tryMatch(SNode s) {
                //条件一：match == null 成立，说明当前Node尚未与任何节点发生过匹配...
                //条件二 成立：使用CAS方式 设置match字段，表示当前Node已经被匹配了
                if (match == null &&
                    UNSAFE.compareAndSwapObject(this, matchOffset, null, s)) {
                    //当前Node如果自旋结束，那么会使用LockSupport.park 方法挂起，挂起之前会将Node对应的Thread 保留到 waiter字段。
                    Thread w = waiter;
                    //条件成立：说明Node对应的Thread已经挂起了...
                    if (w != null) {    // waiters need at most one unpark
                        waiter = null;
                        //使用unpark方式唤醒。
                        LockSupport.unpark(w);
                    }
                    return true;
                }
                return match == s;
            }
           
           
           
             /**
             * Tries to cancel a wait by matching node to itself.
             * 尝试取消..
             */
            void tryCancel() {
                //match字段 保留当前Node对象本身，表示这个Node是取消状态，取消状态的Node，最终会被 强制 移除出栈。
                UNSAFE.compareAndSwapObject(this, matchOffset, null, this);
            }

            //如果match保留的是当前Node本身，那表示当前Node是取消状态，反之 则 非取消状态。
            boolean isCancelled() {
                return match == this;
            }
           
           
        //表示栈顶指针
        volatile SNode head;


        //设置栈顶元素
        boolean casHead(SNode h, SNode nh) {
            return h == head &&
                UNSAFE.compareAndSwapObject(this, headOffset, h, nh);
        }

         /* @param s  SNode引用，当这个引用指向空时，snode方法会创建一个SNode对象 并且赋值给这个引用
         * @param e SNode对象的item字段
         * @param next 指向当前栈帧的下一个栈帧
         * @param mode REQUEST/DATA/FULFILLING
         */
        static SNode snode(SNode s, Object e, SNode next, int mode) {
            if (s == null) s = new SNode(e);
            s.mode = mode;
            s.next = next;
            return s;
        }           

@SuppressWarnings("unchecked")
E transfer(E e, boolean timed, long nanos) {
    /*
     * Basic algorithm is to loop trying one of three actions:
     *
     * 1. If apparently empty or already containing nodes of same
     *    mode, try to push node on stack and wait for a match,
     *    returning it, or null if cancelled.
     *
     * 2. If apparently containing node of complementary mode,
     *    try to push a fulfilling node on to stack, match
     *    with corresponding waiting node, pop both from
     *    stack, and return matched item. The matching or
     *    unlinking might not actually be necessary because of
     *    other threads performing action 3:
     *
     * 3. If top of stack already holds another fulfilling node,
     *    help it out by doing its match and/or pop
     *    operations, and then continue. The code for helping
     *    is essentially the same as for fulfilling, except
     *    that it doesn't return the item.
     */

    //包装当前线程的Node
    SNode s = null; // constructed/reused as needed
    //e == null 条件成立：当前线程是一个REQUEST线程。
    //否则 e!=null 说明 当前线程是一个DATA线程，提交数据的线程。
    int mode = (e == null) ? REQUEST : DATA;

    //自旋
    for (;;) {
        //h 表示栈顶指针
        SNode h = head;

        //CASE1：当前栈内为空 或者 栈顶Node模式与当前请求模式一致，都是需要做入栈操作。
        if (h == null || h.mode == mode) {  // empty or same-mode

            //条件一：成立，说明当前请求是指定了 超时限制的
            //条件二：nanos <= 0 , nanos == 0. 表示这个请求 不支持 “阻塞等待”。 queue.offer();
            if (timed && nanos <= 0) {      // can't wait
                //条件成立：说明栈顶已经取消状态了，协助栈顶出栈。
                if (h != null && h.isCancelled())
                    casHead(h, h.next);     // pop cancelled node
                else
                    //大部分情况从这里返回。
                    return null;

            }

            //什么时候执行else if 呢？
            //当前栈顶为空 或者 模式与当前请求一致，且当前请求允许 阻塞等待。
            //casHead(h, s = snode(s, e, h, mode))  入栈操作。
            else if (casHead(h, s = snode(s, e, h, mode))) {
                //执行到这里，说明 当前请求入栈成功。
                //入栈成功之后要做什么呢？
                //在栈内等待一个好消息，等待被匹配！

                //awaitFulfill 等待被匹配的逻辑...
                //1.正常情况：返回匹配的节点
                //2.取消情况：返回当前节点  s节点进去，返回s节点...
                SNode m = awaitFulfill(s, timed, nanos);


                //条件成立：说明当前Node状态是 取消状态...
                if (m == s) {               // wait was cancelled
                    //将取消状态的节点 出栈...
                    clean(s);
                    //取消状态 最终返回null
                    return null;
                }
                //执行到这里 说明当前Node已经被匹配了...

                //条件一：成立，说明栈顶是有Node
                //条件二：成立，说明 Fulfill 和 当前Node 还未出栈，需要协助出栈。
                if ((h = head) != null && h.next == s)
                    //将fulfill 和 当前Node 结对 出栈
                    casHead(h, s.next);     // help s's fulfiller

                //当前NODE模式为REQUEST类型：返回匹配节点的m.item 数据域
                //当前NODE模式为DATA类型：返回Node.item 数据域，当前请求提交的 数据e
                return (E) ((mode == REQUEST) ? m.item : s.item);
            }
        }
        //什么时候来到这？？
        //栈顶Node的模式与当前请求的模式不一致，会执行else if 的条件。
        //栈顶是 (DATA  Reqeust)    (Request   DATA)   (FULFILLING  REQUEST/DATA)
        //CASE2：当前栈顶模式与请求模式不一致，且栈顶不是FULFILLING
        else if (!isFulfilling(h.mode)) { // try to fulfill
            //条件成立：说明当前栈顶状态为 取消状态，当前线程协助它出栈。
            if (h.isCancelled())            // already cancelled
                //协助 取消状态节点 出栈。
                casHead(h, h.next);         // pop and retry



            //条件成立：说明压栈节点成功，入栈一个 FULFILLING | mode  NODE
            else if (casHead(h, s=snode(s, e, h, FULFILLING|mode))) {
                //当前请求入栈成功

                //自旋，fulfill 节点 和 fulfill.next 节点进行匹配工作...
                for (;;) { // loop until matched or waiters disappear
                    //m 与当前s 匹配节点。
                    SNode m = s.next;       // m is s's match

                    //m == null 什么时候可能成立呢？
                    //当s.next节点 超时或者被外部线程中断唤醒后，会执行 clean 操作 将 自己清理出栈，此时
                    //站在匹配者线程 来看，真有可能拿到一个null。
                    if (m == null) {        // all waiters are gone
                        //将整个栈清空。
                        casHead(s, null);   // pop fulfill node
                        s = null;           // use new node next time
                        //回到外层大的 自旋中，再重新选择路径执行，此时有可能 插入一个节点。
                        break;              // restart main loop
                    }

                    //什么时候会执行到这里呢？
                    //fulfilling 匹配节点不为null，进行真正的匹配工作。

                    //获取 匹配节点的 下一个节点。
                    SNode mn = m.next;
                    //尝试匹配，匹配成功，则将fulfilling 和 m 一起出栈。
                    if (m.tryMatch(s)) {
                        //结对出栈
                        casHead(s, mn);     // pop both s and m

                        //当前NODE模式为REQUEST类型：返回匹配节点的m.item 数据域
                        //当前NODE模式为DATA类型：返回Node.item 数据域，当前请求提交的 数据e
                        return (E) ((mode == REQUEST) ? m.item : s.item);
                    } else                  // lost match
                        //强制出栈
                        s.casNext(m, mn);   // help unlink
                }

            }
        }

        //CASE3：什么时候会执行？
        //栈顶模式为 FULFILLING模式，表示栈顶和栈顶下面的栈帧正在发生匹配...
        //当前请求需要做 协助 工作。
        else {                            // help a fulfiller
            //h 表示的是 fulfilling节点,m fulfilling匹配的节点。
            SNode m = h.next;               // m is h's match
            //m == null 什么时候可能成立呢？
            //当s.next节点 超时或者被外部线程中断唤醒后，会执行 clean 操作 将 自己清理出栈，此时
            //站在匹配者线程 来看，真有可能拿到一个null。
            if (m == null)                  // waiter is gone
                //清空栈
                casHead(h, null);           // pop fulfilling node

            //大部分情况：走else分支。
            else {
                //获取栈顶匹配节点的 下一个节点
                SNode mn = m.next;
                //条件成立：说明 m 和 栈顶 匹配成功
                if (m.tryMatch(h))          // help match
                    //双双出栈，让栈顶指针指向 匹配节点的下一个节点。
                    casHead(h, mn);         // pop both h and m
                else                        // lost match
                    //强制出栈
                    h.casNext(m, mn);       // help unlink
            }
        }
    }
}

transfer -> awaitFulfill

 /*
 * @param s 当前请求Node
 * @param timed 当前请求是否支持 超时限制
 * @param nanos 如果请求支持超时限制，nanos 表示超时等待时长。
 */
SNode awaitFulfill(SNode s, boolean timed, long nanos) {
    /*
     * When a node/thread is about to block, it sets its waiter
     * field and then rechecks state at least one more time
     * before actually parking, thus covering race vs
     * fulfiller noticing that waiter is non-null so should be
     * woken.
     *
     * When invoked by nodes that appear at the point of call
     * to be at the head of the stack, calls to park are
     * preceded by spins to avoid blocking when producers and
     * consumers are arriving very close in time.  This can
     * happen enough to bother only on multiprocessors.
     *
     * The order of checks for returning out of main loop
     * reflects fact that interrupts have precedence over
     * normal returns, which have precedence over
     * timeouts. (So, on timeout, one last check for match is
     * done before giving up.) Except that calls from untimed
     * SynchronousQueue.{poll/offer} don't check interrupts
     * and don't wait at all, so are trapped in transfer
     * method rather than calling awaitFulfill.
     */


    //等待的截止时间。  timed == true  =>  System.nanoTime() + nanos
    final long deadline = timed ? System.nanoTime() + nanos : 0L;

    //获取当前请求线程..
    Thread w = Thread.currentThread();

    //spins 表示当前请求线程 在 下面的 for(;;) 自旋检查中，自旋次数。 如果达到spins自旋次数时，当前线程对应的Node 仍然未被匹配成功，
    //那么再选择 挂起 当前请求线程。
    int spins = (shouldSpin(s) ?
                  //timed == true 指定了超时限制的，这个时候采用 maxTimedSpins == 32 ,否则采用 32 * 16
                 (timed ? maxTimedSpins : maxUntimedSpins) : 0);

    //自旋检查逻辑：1.是否匹配  2.是否超时  3.是否被中断..
    for (;;) {


        //条件成立：说明当前线程收到中断信号，需要设置Node状态为 取消状态。
        if (w.isInterrupted())
            //Node对象的 match 指向 当前Node 说明该Node状态就是 取消状态。
            s.tryCancel();


        //m 表示与当前Node匹配的节点。
        //1.正常情况：有一个请求 与 当前Node 匹配成功，这个时候 s.match 指向 匹配节点。
        //2.取消情况：当前match 指向 当前Node...
        SNode m = s.match;

        if (m != null)
            //可能正常 也可能是 取消...
            return m;



        //条件成立：说明指定了超时限制..
        if (timed) {
            //nanos 表示距离超时 还有多少纳秒..
            nanos = deadline - System.nanoTime();
            //条件成立：说明已经超时了...
            if (nanos <= 0L) {
                //设置当前Node状态为 取消状态.. match-->当前Node
                s.tryCancel();
                continue;
            }
        }





        //条件成立：说明当前线程还可以进行自旋检查...
        if (spins > 0)
            //自旋次数 累积 递减。。。
            spins = shouldSpin(s) ? (spins-1) : 0;


        //spins == 0 ，已经不允许再进行自旋检查了
        else if (s.waiter == null)
            //把当前Node对应的Thread 保存到 Node.waiter字段中..
            s.waiter = w; // establish waiter so can park next iter

        //条件成立：说明当前Node对应的请求  未指定超时限制。
        else if (!timed)
            //使用不指定超时限制的park方法 挂起当前线程，直到 当前线程被外部线程 使用unpark唤醒。
            LockSupport.park(this);

        //什么时候执行到这里？ timed == true 设置了 超时限制..
        //条件成立：nanos > 1000 纳秒的值，只有这种情况下，才允许挂起当前线程..否则 说明 超时给的太少了...挂起和唤醒的成本 远大于 空转自旋...
        else if (nanos > spinForTimeoutThreshold)
            LockSupport.parkNanos(this, nanos);
    }
}

awaitFulfill -》 shouldSpin

boolean shouldSpin(SNode s) {
    //获取栈顶
    SNode h = head;
    //条件一 h == s ：条件成立 说明当前s 就是栈顶，允许自旋检查...
    //条件二 h == null : 什么时候成立？ 当前s节点 自旋检查期间，又来了一个 与当前s 节点匹配的请求，双双出栈了...条件会成立。
    //条件三 isFulfilling(h.mode) ： 前提 当前 s 不是 栈顶元素。并且当前栈顶正在匹配中，这种状态 栈顶下面的元素，都允许自旋检查。
    return (h == s || h == null || isFulfilling(h.mode));
}

transfer -》 clean

void clean(SNode s) {
    //清空数据域
    s.item = null;   // forget item
    //释放线程引用..
    s.waiter = null; // forget thread
    /*
     * At worst we may need to traverse entire stack to unlink
     * s. If there are multiple concurrent calls to clean, we
     * might not see s if another thread has already removed
     * it. But we can stop when we see any node known to
     * follow s. We use s.next unless it too is cancelled, in
     * which case we try the node one past. We don't check any
     * further because we don't want to doubly traverse just to
     * find sentinel.
     */
    //检查取消节点的截止位置
    SNode past = s.next;

    if (past != null && past.isCancelled())
        past = past.next;

    // Absorb cancelled nodes at head
    //当前循环检查节点
    SNode p;
    //从栈顶开始向下检查，将栈顶开始向下连续的 取消状态的节点 全部清理出去，直到碰到past为止。
    while ((p = head) != null && p != past && p.isCancelled())
        casHead(p, p.next);

    // Unsplice embedded nodes
    while (p != null && p != past) {
        //获取p.next
        SNode n = p.next;
        if (n != null && n.isCancelled())
            // n-> x -> y   ===>  n -> y
            p.casNext(n, n.next);
        else
            p = n;
    }
}

难点分析

//CASE2：当前栈顶模式与请求模式不一致，且栈顶不是FULFILLING
else if (!isFulfilling(h.mode)) { // try to fulfill
->
else if (casHead(h, s=snode(s, e, h, FULFILLING|mode))) {
 

->
        //m == null 什么时候可能成立呢？  / m为什么等于null
        if (m == null) {        // all waiters are gone
            //将整个栈清空。
            casHead(s, null);   // pop fulfill node
            s = null;           // use new node next time
            //回到外层大的 自旋中，再重新选择路径执行，此时有可能 插入一个节点。
            break;              // restart main loop
        }

案例分析

public class TransferStackDemo01 {
    public static void main(String[] args) throws InterruptedException {
        SynchronousQueue<Integer> queue = new SynchronousQueue<>();

        Thread thread1 = new Thread(() -> {
            try {
                queue.put(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        thread1.start();

        Thread.sleep(2000);

        Thread thread2 = new Thread(() -> {
            try {
                queue.put(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        thread2.start();

        Thread.sleep(2000);

        Thread thread3 = new Thread(() -> {
            try {
                queue.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        thread3.start();

    }
}