究竟是UNSAFE.compareAndSwapObject的作用

Question

我在阅读JDK ConcurrentLinkedQueue时发现UNSAFE.compareAndSwapObject非常奇怪。 （CLQ类是来自ConcurrentLinkedQueue的副本，以便于调试...）

当我向ConcurrentLinkedQueue提供第一项时。

• 前 p.casNext(null, newNode) head == tail == p == t ref同一个对象，就像这样。

  http://i.stack.imgur.com/8dCO0.png

• 之后进入casNext UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);

  p.next按预期引用newNode，就像这样。

  http://i.stack.imgur.com/mNtUN.png

• 走出去提供

  一切都变得奇怪......我可以理解为什么p.next ref的变化会变成p，如何自动引导newNode ...

  http://i.stack.imgur.com/Pvvcy.png

代码：ConcurrentLinkedQueue.class offer（）

public boolean offer(E e) {
    checkNotNull(e);
    final Node<E> newNode = new Node<E>(e);

    for (Node<E> t = tail, p = t;;) {
        Node<E> q = p.next;
        if (q == null) {
            // p is last node
            if (p.casNext(null, newNode)) {
                // Successful CAS is the linearization point
                // for e to become an element of this queue,
                // and for newNode to become "live".
                if (p != t) // hop two nodes at a time
                    casTail(t, newNode);  // Failure is OK.
                return true;
            }
            // Lost CAS race to another thread; re-read next
        }
        else if (p == q)
            // We have fallen off list.  If tail is unchanged, it
            // will also be off-list, in which case we need to
            // jump to head, from which all live nodes are always
            // reachable.  Else the new tail is a better bet.
            p = (t != (t = tail)) ? t : head;
        else
            // Check for tail updates after two hops.
            p = (p != t && t != (t = tail)) ? t : q;
    }
}