• volatile SNode next
  栈的下一个，就是被当前栈压在下面的栈元素
• volatile SNode match
  节点匹配，用来判断阻塞栈元素能被唤醒的时机
• 比如我们先执行 take，此时队列中没有数据，take 被阻塞了，栈元素为 SNode1
  当有 put 操作时，会把当前 put 的栈元素赋值给 SNode1 的 match 属性，并唤醒 take 操作
  当 take 被唤醒，发现 SNode1 的 match 属性有值时，就能拿到 put 进来的数据，从而返回
• volatile Thread waiter
  栈元素的阻塞是通过线程阻塞来实现的，waiter 为阻塞的线程
• Object item
  未投递的消息，或者未消费的消息

• 入栈
  使用 put 等方法，将数据放到堆栈池中
• 出栈
  使用 take 等方法，把数据从堆栈池中拿出来

@SuppressWarnings("unchecked")
E transfer(E e, boolean timed, long nanos)
SNode s = null; // constructed/reused as needed

// e 为空: take 方法，非空: put 方法
int mode = (e == null) ? REQUEST : DATA;

// 自旋
for (; ; )
// 头节点情况分类
// 1：为空，说明队列中还没有数据
// 2：非空，并且是 take 类型的，说明头节点线程正等着拿数据
// 3：非空，并且是 put 类型的，说明头节点线程正等着放数据
SNode h = head;

// 栈头为空，说明队列中还没有数据。
// 栈头非空且栈头的类型和本次操作一致
//比如都是 put，那么就把本次 put 操作放到该栈头的前面即可，让本次 put 能够先执行
if (h == null || h.mode == mode)// empty or same-mode
// 设置了超时时间，并且 e 进栈或者出栈要超时了，
// 就会丢弃本次操作，返回 null 值。
// 如果栈头此时被取消了，丢弃栈头，取下一个节点继续消费
if (timed & & nanos < = 0)// 无法等待
// 栈头操作被取消
if (h != null & & h.isCancelled())
// 丢弃栈头，把栈头的后一个元素作为栈头
casHead(h, h.next); // 将取消的节点弹栈
// 栈头为空，直接返回 null
else
return null;
// 没有超时，直接把 e 作为新的栈头
else if (casHead(h, s = snode(s, e, h, mode)))
// e 等待出栈，一种是空队列 take，一种是 put
SNode m = awaitFulfill(s, timed, nanos);
if (m == s)// wait was cancelled
clean(s);
return null;

// 本来 s 是栈头的，现在 s 不是栈头了，s 后面又来了一个数，把新的数据作为栈头
if ((h = head) != null & & h.next == s)
casHead(h, s.next); // help ss fulfiller
return (E) ((mode == REQUEST) ? m.item : s.item);

// 栈头正在等待其他线程 put 或 take
// 比如栈头正在阻塞，并且是 put 类型，而此次操作正好是 take 类型，走此处
else if (!isFulfilling(h.mode))// try to fulfill
// 栈头已经被取消，把下一个元素作为栈头
if (h.isCancelled())// already cancelled
casHead(h, h.next); // pop and retry
// snode 方法第三个参数 h 代表栈头，赋值给 s 的 next 属性
else if (casHead(h, s=snode(s, e, h, FULFILLING|mode)))
for (; ; )// loop until matched or waiters disappear
// m 就是栈头，通过上面 snode 方法刚刚赋值
SNode m = s.next; // m is ss match
if (m == null)// all waiters are gone
casHead(s, null); // pop fulfill node
s = null; // use new node next time
break; // restart main loop

SNode mn = m.next;
// tryMatch 非常重要的方法，两个作用：
// 1 唤醒被阻塞的栈头 m，2 把当前节点 s 赋值给 m 的 match 属性
// 这样栈头 m 被唤醒时，就能从 m.match 中得到本次操作 s
// 其中 s.item 记录着本次的操作节点，也就是记录本次操作的数据
if (m.tryMatch(s))
casHead(s, mn); // pop both s and m
return (E) ((mode == REQUEST) ? m.item : s.item);
else// lost match
s.casNext(m, mn); // help unlink


else// help a fulfiller
SNode m = h.next; // m is hs match
if (m == null)// waiter is gone
casHead(h, null); // pop fulfilling node
else
SNode mn = m.next;
if (m.tryMatch(h))// help match
casHead(h, mn); // pop both h and m
else// lost match
h.casNext(m, mn); // help unlink

1. 判断是 put 方法还是 take 方法
2. 判断栈头数据是否为空，如果为空或者栈头的操作和本次操作一致，是的话走 3，否则走 5
3. 判断操作有无设置超时时间，如果设置了超时时间并且已经超时，返回 null，否则走 4
4. 如果栈头为空，把当前操作设置成栈头，或者栈头不为空，但栈头的操作和本次操作相同，也把当前操作设置成栈头，并看看其它线程能否满足自己，不能满足则阻塞自己。比如当前操作是 take，但队列中没有数据，则阻塞自己
5. 如果栈头已经是阻塞住的，需要别人唤醒的，判断当前操作能否唤醒栈头，可以唤醒走 6，否则走 4
6. 把自己当作一个节点，赋值到栈头的 match 属性上，并唤醒栈头节点
7. 栈头被唤醒后，拿到 match 属性，就是把自己唤醒的节点的信息，返回。

/**
* 旋转/阻止，直到节点s通过执行操作匹配。
* @param s 等待的节点
* @param timed true if timed wait
* @param nanos 超时时间
* @return 匹配的节点, 或者是 s 如果被取消
*/
SNode awaitFulfill(SNode s, boolean timed, long nanos)

// deadline 死亡时间，如果设置了超时时间的话，死亡时间等于当前时间 + 超时时间，否则就是 0
final long deadline = timed ? System.nanoTime() + nanos : 0L;
Thread w = Thread.currentThread();
// 自旋的次数，如果设置了超时时间，会自旋 32 次，否则自旋 512 次。
// 比如本次操作是 take 操作，自旋次数后，仍无其他线程 put 数据
// 就会阻塞，有超时时间的，会阻塞固定的时间，否则一致阻塞下去
int spins = (shouldSpin(s) ?
(timed ? maxTimedSpins : maxUntimedSpins) : 0);
for (; ; )
// 当前线程有无被打断，如果过了超时时间，当前线程就会被打断
if (w.isInterrupted())
s.tryCancel();

SNode m = s.match;
if (m != null)
return m;
if (timed)
nanos = deadline - System.nanoTime();
// 超时了，取消当前线程的等待操作
if (nanos < = 0L)
s.tryCancel();
continue;


// 自选次数减1
if (spins > 0)
spins = shouldSpin(s) ? (spins-1) : 0;
// 把当前线程设置成 waiter，主要是通过线程来完成阻塞和唤醒
else if (s.waiter == null)
s.waiter = w; // establish waiter so can park next iter
else if (!timed)
// 通过 park 进行阻塞，这个我们在锁章节中会说明
LockSupport.park(this);
else if (nanos > spinForTimeoutThreshold)
LockSupport.parkNanos(this, nanos);