SynchronousQueue的put方法底层源码

一、SynchronousQueue的put方法底层源码

SynchronousQueue 的 put 方法用于将元素插入队列。由于 SynchronousQueue 没有实际的存储空间，put 方法会阻塞，直到有消费者线程调用 take 方法移除元素

1、put 方法的作用

• 将元素插入队列。

• 如果没有消费者线程等待，当前线程会阻塞，直到有消费者线程移除元素。

• 该方法不会返回任何值，也不会抛出异常（除非线程被中断）。

2、put 方法的源码

以下是 SynchronousQueue 中 put 方法的源码（基于 JDK 17）：

可以看到，put 方法的核心逻辑是通过 transferer.transfer 方法实现的。transferer 是 SynchronousQueue 的内部组件，负责实际的数据传输

3、transferer.transfer 方法

transferer 是一个抽象类，有两个实现：

• TransferStack：用于非公平模式。

• TransferQueue：用于公平模式。

以下是 TransferStack 和 TransferQueue 中 transfer 方法的通用逻辑：

(1）TransferStack.transfer 方法

  E transfer(E e, boolean timed, long nanos) {
      SNode s = null; // 创建一个新节点
      int mode = (e == null) ? REQUEST : DATA; // 判断是生产者还是消费者

      for (;;) {
          SNode h = head; // 获取栈顶节点
          if (h == null || h.mode == mode) { // 如果栈为空或模式匹配
              if (timed && nanos <= 0) { // 如果超时
                  if (h != null && h.isCancelled()) // 如果节点已取消
                      casHead(h, h.next); // 移除已取消的节点
                  else
                      return null; // 返回 null
              } else if (casHead(h, s = snode(s, e, h, mode))) { // 尝试插入新节点
                  SNode m = awaitFulfill(s, timed, nanos); // 等待匹配
                  if (m == s) { // 如果节点被取消
                      clean(s); // 清理节点
                      return null; // 返回 null
                  }
                  if ((h = head) != null && h.next == s) // 如果匹配成功
                      casHead(h, s.next); // 移除匹配的节点
                  return (E) ((mode == REQUEST) ? m.item : s.item); // 返回数据
              }
          } else if (!isFulfilling(h.mode)) { // 如果栈顶节点未完成匹配
              if (h.isCancelled()) // 如果节点已取消
                  casHead(h, h.next); // 移除已取消的节点
              else if (casHead(h, s=snode(s, e, h, FULFILLING|mode))) { // 尝试插入新节点
                  for (;;) {
                      SNode m = s.next; // 获取下一个节点
                      if (m == null) { // 如果下一个节点为空
                          casHead(s, null); // 重置栈顶
                          s = null; // 重置节点
                          break;
                      }
                      SNode mn = m.next;
                      if (m.tryMatch(s)) { // 尝试匹配
                          casHead(s, mn); // 移除匹配的节点
                          return (E) ((mode == REQUEST) ? m.item : s.item); // 返回数据
                      } else
                          s.casNext(m, mn); // 移除未匹配的节点
                  }
              }
          } else { // 如果栈顶节点已完成匹配
              SNode m = h.next; // 获取下一个节点
              if (m == null) // 如果下一个节点为空
                  casHead(h, null); // 重置栈顶
              else {
                  SNode mn = m.next;
                  if (m.tryMatch(h)) // 尝试匹配
                      casHead(h, mn); // 移除匹配的节点
                  else
                      h.casNext(m, mn); // 移除未匹配的节点
              }
          }
      }
  }

(2）TransferQueue.transfer 方法

  E transfer(E e, boolean timed, long nanos) {
      QNode s = null; // 创建一个新节点
      boolean isData = (e != null); // 判断是生产者还是消费者

      for (;;) {
          QNode t = tail;
          QNode h = head;
          if (t == null || h == null) // 如果队列未初始化
              continue;

          if (h == t || t.isData == isData) { // 如果队列为空或模式匹配
              QNode tn = t.next;
              if (t != tail) // 如果 tail 已更新
                  continue;
              if (tn != null) { // 如果 tail 未更新
                  advanceTail(t, tn); // 更新 tail
                  continue;
              }
              if (timed && nanos <= 0) // 如果超时
                  return null; // 返回 null
              if (s == null) // 如果节点未初始化
                  s = new QNode(e, isData); // 创建新节点
              if (!t.casNext(null, s)) // 尝试插入新节点
                  continue;

              advanceTail(t, s); // 更新 tail
              Object x = awaitFulfill(s, e, timed, nanos); // 等待匹配
              if (x == s) { // 如果节点被取消
                  clean(t, s); // 清理节点
                  return null; // 返回 null
              }

              if (!s.isOffList()) { // 如果节点未移除
                  advanceHead(t, s); // 更新 head
                  if (x != null) // 如果匹配成功
                      s.item = s; // 标记节点
                  s.waiter = null; // 清除等待线程
              }
              return (x != null) ? (E)x : e; // 返回数据
          } else { // 如果模式不匹配
              QNode m = h.next;
              if (t != tail || m == null || h != head) // 如果队列已更新
                  continue;

              Object x = m.item;
              if (isData == (x != null) || x == m || !m.casItem(x, e)) { // 如果匹配失败
                  advanceHead(h, m); // 移除未匹配的节点
                  continue;
              }

              advanceHead(h, m); // 更新 head
              LockSupport.unpark(m.waiter); // 唤醒等待线程
              return (x != null) ? (E)x : e; // 返回数据
          }
      }
  }

4、关键点总结

• 无存储空间：SynchronousQueue 没有容量，插入和移除操作必须一一对应。

• 阻塞行为：如果没有配对的插入或移除操作，线程会一直阻塞。

• 公平性：公平模式下，等待时间最长的线程优先获得执行机会。

二、SynchronousQueue的类结构

先看一下SynchronousQueue类里面有哪些属性：

public class SynchronousQueue<E>
        extends AbstractQueue<E>
        implements BlockingQueue<E>, java.io.Serializable {

    /**
     * 转接器（栈和队列的父类）
     */
    abstract static class Transferer<E> {

        /**
         * 转移（put和take都用这一个方法）
         *
         * @param e     元素
         * @param timed 是否超时
         * @param nanos 纳秒
         */
        abstract E transfer(E e, boolean timed, long nanos);

    }

    /**
     * 栈实现类
     */
    static final class TransferStack<E> extends Transferer<E> {
    }

    /**
     * 队列实现类
     */
    static final class TransferQueue<E> extends Transferer<E> {
    }

}

SynchronousQueue底层是基于Transferer抽象类实现的，放数据和取数据的逻辑都耦合在transfer()方法中。而Transferer抽象类又有两个实现类，分别是基于栈结构实现和基于队列实现

1、初始化

SynchronousQueue常用的初始化方法有两个：

• 1、无参构造方法

• 2、指定容量大小的有参构造方法

     /**
      * 无参构造方法
      */
     BlockingQueue<Integer> blockingQueue1 = new SynchronousQueue<>();
  
     /**
      * 有参构造方法，指定是否使用公平锁（默认使用非公平锁）
      */
     BlockingQueue<Integer> blockingQueue2 = new SynchronousQueue<>(true);
  

再看一下对应的源码实现：

  /**
   * 无参构造方法
   */
  public SynchronousQueue() {
      this(false);
  }

  /**
   * 有参构造方法，指定是否使用公平锁
   */
  public SynchronousQueue(boolean fair) {
      transferer = fair ? new TransferQueue<E>() : new TransferStack<E>();
  }

可以看出SynchronousQueue的无参构造方法默认使用的非公平策略，有参构造方法可以指定使用公平策略。 操作策略：

• 1、公平策略，基于队列实现的是公平策略，先进先出。

• 2、非公平策略，基于栈实现的是非公平策略，先进后出。

2、栈的类结构

/**
 * 栈实现
 */
static final class TransferStack<E> extends Transferer<E> {

    /**
     * 头节点（也是栈顶节点）
     */
    volatile SNode head;

    /**
     * 栈节点类
     */
    static final class SNode {

        /**
         * 当前操作的线程
         */
        volatile Thread waiter;

        /**
         * 节点值（取数据的时候，该字段为null）
         */
        Object item;

        /**
         * 节点模式（也叫操作类型）
         */
        int mode;

        /**
         * 后继节点
         */
        volatile SNode next;

        /**
         * 匹配到的节点
         */
        volatile SNode match;

    }
}

节点模式有以下三种：

3、栈的transfer方法实现

transfer()方法中，把放数据和取数据的逻辑耦合在一块了，逻辑有点绕，不过核心逻辑就四点，把握住就能豁然开朗。其实就是从栈顶压入，从栈顶弹出。

详细流程如下：

1、首先判断当前线程的操作类型与栈顶节点的操作类型是否一致，比如都是放数据，或者都是取数据。

2、如果是一致，把当前操作包装成SNode节点，压入栈顶，并挂起当前线程。

3、如果不一致，表示相互匹配（比如当前操作是放数据，而栈顶节点是取数据，或者相反）。然后也把当前操作包装成SNode节点压入栈顶，并使用tryMatch()方法匹配两个节点，匹配成功后，弹出两个这两个节点，并唤醒栈顶节点线程，同时把数据传递给栈顶节点线程，最后返回。

4、栈顶节点线程被唤醒，继续执行，然后返回传递过来的数据。

  /**
   * 转移（put和take都用这一个方法）
   *
   * @param e     元素（取数据的时候，元素为null）
   * @param timed 是否超时
   * @param nanos 纳秒
   */
  E transfer(E e, boolean timed, long nanos) {
      SNode s = null;
      // 1. e为null，表示要取数据，否则是放数据
      int mode = (e == null) ? REQUEST : DATA;
      for (; ; ) {
          SNode h = head;
          // 2. 如果本次操作跟栈顶节点模式相同（都是取数据，或者都是放数据），就把本次操作包装成SNode，压入栈顶
          if (h == null || h.mode == mode) {
              if (timed && nanos <= 0) {
                  if (h != null && h.isCancelled()) {
                      casHead(h, h.next);
                  } else {
                      return null;
                  }
                  // 3. 把本次操作包装成SNode，压入栈顶，并挂起当前线程
              } else if (casHead(h, s = snode(s, e, h, mode))) {
                  // 4. 挂起当前线程
                  SNode m = awaitFulfill(s, timed, nanos);
                  if (m == s) {
                      clean(s);
                      return null;
                  }
                  // 5. 当前线程被唤醒后，如果栈顶有了新节点，就删除当前节点
                  if ((h = head) != null && h.next == s) {
                      casHead(h, s.next);
                  }
                  return (E) ((mode == REQUEST) ? m.item : s.item);
              }
              // 6. 如果栈顶节点类型跟本次操作不同，并且模式不是FULFILLING类型
          } else if (!isFulfilling(h.mode)) {
              if (h.isCancelled()) {
                  casHead(h, h.next);
              }
              // 7. 把本次操作包装成SNode（类型是FULFILLING），压入栈顶
              else if (casHead(h, s = snode(s, e, h, FULFILLING | mode))) {
                  // 8. 使用死循环，直到匹配到对应的节点
                  for (; ; ) {
                      // 9. 遍历下个节点
                      SNode m = s.next;
                      // 10. 如果节点是null，表示遍历到末尾，设置栈顶节点是null，结束。
                      if (m == null) {
                          casHead(s, null);
                          s = null;
                          break;
                      }
                      SNode mn = m.next;
                      // 11. 如果栈顶的后继节点跟栈顶节点匹配成功，就删除这两个节点，结束。
                      if (m.tryMatch(s)) {
                          casHead(s, mn);
                          return (E) ((mode == REQUEST) ? m.item : s.item);
                      } else {
                          // 12. 如果没有匹配成功，就删除栈顶的后继节点，继续匹配
                          s.casNext(m, mn);
                      }
                  }
              }
          } else {
              // 13. 如果栈顶节点类型跟本次操作不同，并且是FULFILLING类型，
              // 就再执行一遍上面第8步for循环中的逻辑（很少概率出现）
              SNode m = h.next;
              if (m == null) {
                  casHead(h, null);
              } else {
                  SNode mn = m.next;
                  if (m.tryMatch(h)) {
                      casHead(h, mn);
                  } else {
                      h.casNext(m, mn);
                  }
              }
          }
      }
  }

不用关心细枝末节，把握住代码核心逻辑即可。 再看一下第4步，挂起线程的代码逻辑： 核心逻辑就两条：

• 第6步，挂起当前线程

• 第3步，当前线程被唤醒后，直接返回传递过来的match节点

   /**
    * 等待执行
    *
    * @param s     节点
    * @param timed 是否超时
    * @param nanos 超时时间
    */
   SNode awaitFulfill(SNode s, boolean timed, long nanos) {
       // 1. 计算超时时间
       final long deadline = timed ? System.nanoTime() + nanos : 0L;
       Thread w = Thread.currentThread();
       // 2. 计算自旋次数
       int spins = (shouldSpin(s) ?
               (timed ? maxTimedSpins : maxUntimedSpins) : 0);
       for (; ; ) {
           if (w.isInterrupted())
               s.tryCancel();
           // 3. 如果已经匹配到其他节点，直接返回
           SNode m = s.match;
           if (m != null)
               return m;
           if (timed) {
               // 4. 超时时间递减
               nanos = deadline - System.nanoTime();
               if (nanos <= 0L) {
                   s.tryCancel();
                   continue;
               }
           }
           // 5. 自旋次数减一
           if (spins > 0)
               spins = shouldSpin(s) ? (spins - 1) : 0;
           else if (s.waiter == null)
               s.waiter = w;
               // 6. 开始挂起当前线程
           else if (!timed)
               LockSupport.park(this);
           else if (nanos > spinForTimeoutThreshold)
               LockSupport.parkNanos(this, nanos);
       }
   }
  

再看一下匹配节点的tryMatch()方法逻辑： 作用就是唤醒栈顶节点，并当前节点传递给栈顶节点。

  /**
   * 匹配节点
   *
   * @param s 当前节点
   */
  boolean tryMatch(SNode s) {
      if (match == null &&
              UNSAFE.compareAndSwapObject(this, matchOffset, null, s)) {
          Thread w = waiter;
          if (w != null) {
              waiter = null;
              // 1. 唤醒栈顶节点
              LockSupport.unpark(w);
          }
          return true;
      }
      // 2. 把当前节点传递给栈顶节点
      return match == s;
  }

4、队列的类结构

  /**
   * 队列实现
   */
  static final class TransferQueue<E> extends Transferer<E> {

      /**
       * 头节点
       */
      transient volatile QNode head;

      /**
       * 尾节点
       */
      transient volatile QNode tail;

      /**
       * 队列节点类
       */
      static final class QNode {

          /**
           * 当前操作的线程
           */
          volatile Thread waiter;

          /**
           * 节点值
           */
          volatile Object item;

          /**
           * 后继节点
           */
          volatile QNode next;

          /**
           * 当前节点是否为数据节点
           */
          final boolean isData;
      }
  }

可以看出TransferQueue队列是使用带有头尾节点的单链表实现的。 还有一点需要提一下，TransferQueue默认构造方法，会初始化头尾节点，默认是空节点。

/**
 * TransferQueue默认的构造方法
 */
TransferQueue() {
    QNode h = new QNode(null, false);
    head = h;
    tail = h;
}

队列的transfer方法实现

队列使用的公平策略，体现在，每次操作的时候，都是从队尾压入，从队头弹出。 详细流程如下：

1、首先判断当前线程的操作类型与队尾节点的操作类型是否一致，比如都是放数据，或者都是取数据。

2、如果是一致，把当前操作包装成QNode节点，压入队尾，并挂起当前线程。

3、如果不一致，表示相互匹配（比如当前操作是放数据，而队尾节点是取数据，或者相反）。然后在队头节点开始遍历，找到与当前操作类型相匹配的节点，把当前操作的节点值传递给这个节点，并弹出这个节点，唤醒这个节点的线程，最后返回。

4、队头节点线程被唤醒，继续执行，然后返回传递过来的数据。

    /**
     * 转移（put和take都用这一个方法）
     *
     * @param e     元素（取数据的时候，元素为null）
     * @param timed 是否超时
     * @param nanos 超时时间
     */
    E transfer(E e, boolean timed, long nanos) {
        QNode s = null;
        // 1. e不为null，表示要放数据，否则是取数据
        boolean isData = (e != null);
        for (; ; ) {
            QNode t = tail;
            QNode h = head;
            if (t == null || h == null) {
                continue;
            }

            // 2. 如果本次操作跟队尾节点模式相同（都是取数据，或者都是放数据），就把本次操作包装成QNode，压入队尾
            if (h == t || t.isData == isData) {
                QNode tn = t.next;
                if (t != tail) {
                    continue;
                }
                if (tn != null) {
                    advanceTail(t, tn);
                    continue;
                }
                if (timed && nanos <= 0) {
                    return null;
                }
                // 3. 把本次操作包装成QNode，压入队尾
                if (s == null) {
                    s = new QNode(e, isData);
                }
                if (!t.casNext(null, s)) {
                    continue;
                }
                advanceTail(t, s);
                // 4. 挂起当前线程
                Object x = awaitFulfill(s, e, timed, nanos);
                // 5. 当前线程被唤醒后，返回返回传递过来的节点值
                if (x == s) {
                    clean(t, s);
                    return null;
                }
                if (!s.isOffList()) {
                    advanceHead(t, s);
                    if (x != null) {
                        s.item = s;
                    }
                    s.waiter = null;
                }
                return (x != null) ? (E) x : e;
            } else {
                // 6. 如果本次操作跟队尾节点模式不同，就从队头结点开始遍历，找到模式相匹配的节点
                QNode m = h.next;
                if (t != tail || m == null || h != head) {
                    continue;
                }

                Object x = m.item;
                // 7. 把当前节点值e传递给匹配到的节点m
                if (isData == (x != null) || x == m ||
                        !m.casItem(x, e)) {
                    advanceHead(h, m);
                    continue;
                }
                // 8. 弹出队头节点，并唤醒节点m
                advanceHead(h, m);
                LockSupport.unpark(m.waiter);
                return (x != null) ? (E) x : e;
            }
        }
    }