【原创】Java并发编程系列29 | ConcurrentLinkedQueue

public class ConcurrentLinkedQueue<E> {
    private transient volatile Node<E> head;
    private transient volatile Node<E> tail;

    /**
     * 节点类
     * CAS保证节点操作安全
     */
    private static class Node<E> {
        volatile E item;
        volatile Node<E> next;

        Node(E item) {
            // 获得item 和 next 的偏移量
            UNSAFE.putObject(this, itemOffset, item);
        }

        /**
         * 更改Node中的数据域item
         */
        boolean casItem(E cmp, E val) {
            return UNSAFE.compareAndSwapObject(this, itemOffset, cmp, val);
        }

        /**
         * 更改Node中的指针域next
         */
        void lazySetNext(Node<E> val) {
            UNSAFE.putOrderedObject(this, nextOffset, val);
        }

        /**
         * 更改Node中的指针域next
         */
        boolean casNext(Node<E> cmp, Node<E> val) {
            return UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);
        }
    }

    /**入队*/
    public boolean offer(E e)
    /**出队*/
    public E poll()
}

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) {//(1)
            /*
             * q == null 表示p是最后一个节点，设置t.next=newNode
             * 如果失败，说明表示其他线程已经修改了p的指向，循环尝试直到成功
             */
            if (p.casNext(null, newNode)) {// 2)
                // node 加入节点后会导致tail距离最后一个节点相差大于一个，需要更新tail
                if (p != t)//(3)
                    casTail(t, newNode);//(4) casTail：设置tail 尾节点
                return true;
            }
        }
        else if (p == q)//(5)
            /*
             * 多线程环境下，offer(e)和poll()同时执行，
             * 此时p节点被poll()，设置了p.next=p，所以此时q=p.next=p
             * 这里要重新设置p结点
             */
            p = (t != (t = tail)) ? t : head;//(6)
        else
            // tail并没有指向尾节点，重新设置p
            p = (p != t && t != (t = tail)) ? t : q;//(7)
    }
}

public E poll() {
    restartFromHead:// 如果出现p被删除的情况需要从head重新开始
    for (;;) {
        for (Node<E> h = head, p = h, q;;) {
            E item = p.item;
            // item不为null，将item返回并设置为null
            if (item != null && p.casItem(item, null)) {//(1)
                if (p != h)//(2)
                    /*
                     * p != head 则更新head
                     * p.next != null，则将head更新为p.next ,否则更新为p
                     */
                    updateHead(h, ((q = p.next) != null) ? q : p);//(3)
                return item;
            }
            // p.next == null 队列为空
            else if ((q = p.next) == null)//(4)
                updateHead(h, p);
                return null;
            }
            // 另一个线程已经把p从队列中删除并设置p.next = p，p已经被移除不能继续，需要重新开始
            else if (p == q)//(5)
                continue restartFromHead;
            else
                p = q;//(6)
        }
    }
}

/**
 * 更新head
 */
final void updateHead(Node<E> h, Node<E> p) {
    if (h != p && casHead(h, p))
        h.lazySetNext(h);
}