一条链表，排着的要么全是货，要么全是等货的人

var sq = new SynchronousQueue<Task>();        // 默认不公平（栈）；new SynchronousQueue<>(true) 是公平（队列）
sq.put(t);                 // 等到有人取走
boolean ok = sq.offer(t);  // 现在就有人在等才成功，否则 false
Task x = sq.take();        // 等到有人放
Task y = sq.poll(1, SECONDS);   // 最多等 1 秒，超时返回 null

var q = new LinkedTransferQueue<Task>();      // 无界，先来先得
q.put(t);                  // 放下就走，从不阻塞
q.transfer(t);             // 等到有人取走（像 SQ.put）
boolean got = q.tryTransfer(t, 1, SECONDS);   // 1 秒内没人取就撤回
boolean someone = q.hasWaitingConsumer();     // 有没有人停在 take/poll 上

import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.LockSupport;

// 极简双重队列（FIFO）：只有 put（等到被取走才返回）和 take，不支持超时和中断
public class MiniDualQueue<E> {
  static final class Node {
    final boolean isData;                                  // true：数据节点；false：请求节点
    final AtomicReference<Object> item;                    // 数据节点 x→null、请求节点 null→x，就是“交接”
    final AtomicReference<Node> next = new AtomicReference<>();
    volatile Thread waiter;
    Node(Object x, boolean isData) { this.item = new AtomicReference<>(x); this.isData = isData; }
  }
  private final AtomicReference<Node> head, tail;
  public MiniDualQueue() {
    Node dummy = new Node(null, true);                     // 哑节点：isData 却没数据，算“已配对”
    head = new AtomicReference<>(dummy); tail = new AtomicReference<>(dummy);
  }
  public void put(E e) { xfer(e); }
  @SuppressWarnings("unchecked") public E take() { return (E) xfer(null); }

  private Object xfer(Object e) {
    boolean haveData = (e != null);
    Node s = null;
    for (;;) {
      Node t = tail.get(), h = head.get();
      if (h == t || t.isData == haveData) {                // 空，或者排着的是同类：排到队尾
        Node tn = t.next.get();
        if (t != tail.get()) continue;
        if (tn != null) { tail.compareAndSet(t, tn); continue; }   // tail 落后了，帮它往前推
        if (s == null) s = new Node(e, haveData);
        if (!t.next.compareAndSet(null, s)) continue;      // 别人先追加了，重来
        tail.compareAndSet(t, s);
        Object x = await(s, e);
        if (head.get() == t) head.compareAndSet(t, s);     // 帮忙把 head 推过自己
        return (x != null) ? x : e;
      } else {                                             // 排着的是异类：和第一个配对
        Node m = h.next.get();
        if (t != tail.get() || m == null || h != head.get()) continue;   // 读到的不一致，重来
        Object x = m.item.get();
        boolean ok = (haveData == (x == null)) && m.item.compareAndSet(x, e);
        head.compareAndSet(h, m);                          // 不管成没成功，m 都不再是活节点了
        if (!ok) continue;                                 // 被别人抢先配对了
        LockSupport.unpark(m.waiter);
        return (x != null) ? x : e;
      }
    }
  }
  private Object await(Node s, Object e) {                 // 先自旋，再挂起
    for (int spins = 128;;) {
      Object x = s.item.get();
      if (x != e) return x;
      if (spins > 0) { spins--; Thread.onSpinWait(); }
      else if (s.waiter == null) s.waiter = Thread.currentThread();   // 先登记，再复查一遍 item
      else LockSupport.park(this);
    }
  }
}

import java.util.*;
import java.util.concurrent.*;

// 看 SynchronousQueue 和 LinkedTransferQueue 的行为；JDK 11+ 直接 java SqPeek.java
public class SqPeek {
  // 让 n 个线程按 A、B、C… 的先后顺序停在 take() 上，再依次放入 1..n，看谁拿到几
  static String order(BlockingQueue<Integer> q, int n) throws Exception {
    var got = new ConcurrentSkipListMap<Integer, String>();
    var ts = new ArrayList<Thread>();
    for (int i = 0; i < n; i++) {
      String name = String.valueOf((char) ('A' + i));
      Thread t = new Thread(() -> { try { got.put(q.take(), name); } catch (InterruptedException e) { } });
      t.start(); ts.add(t);
      while (t.getState() != Thread.State.WAITING) Thread.sleep(1);   // 确认它已经停住
    }
    for (int v = 1; v <= n; v++) q.put(v);
    for (Thread t : ts) t.join();
    return got.toString();
  }

  public static void main(String[] args) throws Exception {
    System.out.println("JDK " + Runtime.version());
    var tr = Class.forName("java.util.concurrent.SynchronousQueue$Transferer");
    System.out.println("① SynchronousQueue$Transferer 的父类：" + tr.getSuperclass().getName());

    var sq = new SynchronousQueue<String>();
    System.out.println("② 没人在取：offer(\"x\") = " + sq.offer("x") + "，poll() = " + sq.poll() + "，size() = " + sq.size());
    Thread waiting = new Thread(() -> { try { sq.take(); } catch (InterruptedException e) { } });
    waiting.start(); while (waiting.getState() != Thread.State.WAITING) Thread.sleep(1);
    System.out.println("   有人停在 take() 上：size() = " + sq.size() + "，isEmpty() = " + sq.isEmpty() + "，offer(\"x\") = " + sq.offer("x"));
    waiting.join();

    System.out.println("③ 默认（不公平）：" + order(new SynchronousQueue<>(), 3) + "  ← 值 → 拿到它的线程");
    System.out.println("   公平 true：   " + order(new SynchronousQueue<>(true), 3));

    var ltq = new LinkedTransferQueue<String>();
    ltq.put("a"); ltq.put("b");
    System.out.println("④ LTQ put 两次就返回：size() = " + ltq.size() + "；tryTransfer(\"c\") = " + ltq.tryTransfer("c") + "（没人在等）");
    ltq.clear();
    Thread consumer = new Thread(() -> { try { Thread.sleep(300); System.out.println("   消费者 300 ms 后 take() = " + ltq.take()); } catch (InterruptedException e) { } });
    consumer.start();
    long t0 = System.nanoTime(); ltq.transfer("d");
    System.out.println("   transfer(\"d\") 等了 " + (System.nanoTime() - t0) / 1_000_000 + " ms 才返回");
    consumer.join();
    Thread c2 = new Thread(() -> { try { ltq.take(); } catch (InterruptedException e) { } });
    c2.start(); while (c2.getState() != Thread.State.WAITING) Thread.sleep(1);
    System.out.println("   有人在等：hasWaitingConsumer() = " + ltq.hasWaitingConsumer() + "，getWaitingConsumerCount() = " + ltq.getWaitingConsumerCount() + "，size() = " + ltq.size());
    ltq.put("e"); c2.join();
  }
}

$ java SqPeek.java
JDK 21.0.12.1+1-1-22.04.4-Ubuntu
① SynchronousQueue$Transferer 的父类：java.util.concurrent.LinkedTransferQueue
② 没人在取：offer("x") = false，poll() = null，size() = 0
   有人停在 take() 上：size() = 0，isEmpty() = true，offer("x") = true
③ 默认（不公平）：{1=C, 2=B, 3=A}  ← 值 → 拿到它的线程
   公平 true：   {1=A, 2=B, 3=C}
④ LTQ put 两次就返回：size() = 2；tryTransfer("c") = false（没人在等）
   消费者 300 ms 后 take() = d
   transfer("d") 等了 300 ms 才返回
   有人在等：hasWaitingConsumer() = true，getWaitingConsumerCount() = 1，size() = 0

JDK 11.0.32.1+1-post-1ubuntu1-22.04-Ubuntu
① SynchronousQueue$Transferer 的父类：java.lang.Object      ← 老实现：自己的 TransferStack / TransferQueue
（②～④ 和上面一字不差）

574    final Object xfer(Object e, long ns) {575        boolean haveData = (e != null);576        Object m;                           // the match or e if none577        DualNode s = null, p;               // enqueued node and its predecessor578        restart: for (DualNode prevp = null;;) {579            DualNode h, t, q;580            if ((h = head) == null &&       // initialize unless immediate❶581                (ns == 0L ||582                 (h = cmpExHead(null, s = new DualNode(e, haveData))) == null)) {583                p = null;                   // no predecessor584                break;                      // else lost init race585            }586            p = (t = tail) != null && t.isData == haveData && t != prevp ? t : h;❷587            prevp = p;                      // avoid known self-linked tail path588            do {589                m = p.item;590                q = p.next;591                if (p.isData != haveData && haveData != (m != null) &&❸592                    p.cmpExItem(m, e) == m) {❹593                    Thread w = p.waiter;    // matched complementary node594                    if (p != h && h == cmpExHead(h, (q == null) ? p : q))❺595                        h.next = h;         // advance head; self-link old596                    LockSupport.unpark(w);❻597                    return m;598                } else if (q == null) {599                    if (ns == 0L)           // try to append unless immediate❼600                        break restart;601                    if (s == null)602                        s = new DualNode(e, haveData);603                    if ((q = p.cmpExNext(null, s)) == null) {❽604                        if (p != t)❾605                            cmpExTail(t, s);606                        break restart;607                    }608                }609            } while (p != (p = q));         // restart if self-linked❿610        }611        if (s == null || ns <= 0L)612            m = e;                          // don't wait613        else if ((m = s.await(e, ns, this,  // spin if at or near headundefined614                              p == null || p.waiter == null)) == e)615            unsplice(p, s);                 // cancelled616        else if (m != null)617            s.selfLinkItem();618619        return m;620    }