ConcurrentLinkedQueue源码解读

1.简介

ConcurrentLinkedQueue是JUC中的基于链表的无锁队列实现。本文将解读其源码实现。

2. 论文

ConcurrentLinkedQueue的实现是以Maged M. Michael和Michael L. Scott的论文Simple, Fast, and Practical Non-Blocking and Blocking Concurrent Queue Algorithms为原型进行改造的，不妨阅读此篇论文。

下面我将论文中的介绍的入队与出队用接近Java语言的形式改写并加上注释。

enq
    node = new Node(value, null)
    loop
        tail = this.tail
        next = tail.next
        # 如果tail已经不是尾节点，重试循环。
        if tail == this.tail
            # 队列处于稳定状态，尝试插入节点。
            if next == null
                # 插入新节点，将尾节点与新节点链接起来。
                # 如果成功则退出循环，否则重试。
                if CAS(tail.next, next, <node, next.count+1>
                    break
            # 队列处于中间状态，推进尾节点。
            else
                CAS (this.tail, tail, <next, tail.count+1>)
    # 将尾节点更新为新插入的节点，失败没关系，说明其它线程更新了尾节点。
    CAS(this.tail, tail, <node, tail.count+1>)

deq
    loop
        head = this.head
        tail = this.tail
        next = head.next
        # 如果head已经不是头节点，重试循环。
        if head == this.head
            if head == tail
                # 队列处于稳定状态则出队失败。
                if next == null
                    return false
                # 有其它线程正在入队，推进尾节点。
                CAS(this.tail, tail, <next, tail.count+1>)
            else
                # 成功将队列头节点CAS到下一个节点则出队成功，退出循环。
                if CAS(this.head, head, <next, head.count+1>)
                    break
    return true

由于Java自带垃圾回收，加上ConcurrentLinkedQueue对节点进行CAS且其内外方法都保证了节点不会复用，所以并不会出现ABA问题，因此节点不需要版本号。

3. ConcurrentLinkedQueue的实现

3.1 数据结构

正如典型的队列设计，内部的节点用如下的Node类表示

/**
 * 仅展示属性，其余略去。
 */
private static class Node<E> {
    volatile E item;
    volatile Node<E> next;
}

值得一提的是Node中有一个lazySetNext方法

void lazySetNext(Node<E> val) {
    UNSAFE.putOrderedObject(this, nextOffset, val);
}

与AtomicReference类一样，使用了UNSAFE.putOrderedObject方法来实现低延迟的写入。这个方法会插入Store-Store内存屏障，也就是保证写操作不会重排。而不会插入普通volatile写会插入的Store-Load屏障。

ConcurrentLinkedQueue在构造时会初始化head和tail为一个item为null的节点，作为哨兵节点。

private transient volatile Node<E> head;

private transient volatile Node<E> tail;

3.2 设计思想

ConcurrentLinkedQueue的源码还是有些晦涩难懂的，但是doc非常详细，对阅读源码非常有帮助。如果带着从doc中介绍的设计与实现思路去读源码会轻松不少。

ConcurrentLinkedQueue是不允许向其插入空的item的，对于删除元素，会将其item给CAS为null，一旦某个元素的item变为null，就意味着它不再是队列中的有效元素了，并且会将已删除节点的next指针指向自身。

这样可以实现尽可能快地从已删除的元素跳过后面删除的元素，回到队列中。

ConcurrentLinkedQueue具有以下这些性质：

• 队列中任意时刻只有最后一个元素的next为null
• head和tail不会是null（哨兵节点的设计）
• head未必是队列中第一个元素（head指向的可能是一个已经被移除的元素）
• 队列中的有效元素都可以从head通过succ方法遍历到
• tail未必是队列中最后一个元素（tail.next可以不为null）
• 队列中的最后一个元素可以从tail通过succ方法遍历到
• tail甚至可以是head的前驱

这里提到了succ方法，那么先睹为快，看一下succ方法吧。

final Node<E> succ(Node<E> p) {
    Node<E> next = p.next;
    // 如果next就是自身（代表已经不在队列中），则返回head，否则返回next。
    return (p == next) ? head : next;
}

因为ConcurrentLinkedQueue中的head和tail都可能会滞后，这其实是一种避免频繁CAS的优化。当然过度的滞后也是会影响操作效率的，所以在具体实现的时候，会尽可能能有机会更新head和tail就去更新它们。

3.3 源码解读

3.3.1 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;
        // 如果p的next为null，则说明此刻p为队列中最后一个元素。
        if (q == null) {
            /*
             * cas成功则newNode成功入队，只是此刻tail还是老的。
             * 否则说明因为线程竞争的关系没有成功入队，需要重试。
             */
            if (p.casNext(null, newNode)) {
                /*
                 * t是当前线程读到的tail快照，p是上面CAS时队列中最后一个元素。
                 * 这两者不一致说明该更新tail了。
                 * 如果CAS失败则说明tail已经被其它线程更新过了，这没关系。
                 */
                if (p != t)
                    casTail(t, newNode);
                return true;
            }
        }
        /*
         * ConcurrentLinkedQueue的一个设计就是对于已经移除的元素，
         * 会将next置为本身，用于判断当前元素已经出队，接着从head继续遍历(可以看succ方法)。
         *
         * 在整个offer方法的执行过程中，p一定是等于t或者在t的后面的，
         * 因此如果p已经不在队列中的话，t也一定不在队列中了。
         *
         * 所以重新读取一次tail到快照t，
         * 如果t未发生变化，就从head开始继续下去。
         * 否则让p从新的t开始继续尝试入队是一个更好的选择(此时新的t很可能在head后面)
         */
        else if (p == q)
            p = (t != (t = tail)) ? t : head;
        else
            /*
             * 如果p与t相等，则让p继续向后移动一个节点。
             *
             * 如果p和t不相等，则说明已经经历至少两轮循环(仍然没有入队)，
             * 则重新读取一次tail到t，如果t发生了变化，则从t开始再次尝试入队。
             */
            p = (p != t && t != (t = tail)) ? t : q;
    }
}

3.3.2 poll方法

public E poll() {
restartFromHead:
    for (;;) {
        // p初始设置为head。
        for (Node<E> h = head, p = h, q;;) {
            E item = p.item;

            /*
             * 成功将item给CAS为null则说明成功移除了元素。
             * 这里的item != null判断也是为了尽可能避免无意义的CAS。
             */
            if (item != null && p.casItem(item, null)) {
                /*
                 * p如果与h不相等，则说明head很可能滞后,指向已不在队列中的元素。
                 * 如果此时p有后继，则更新head为p.next，
                 * 否则尽管p已经被移除出去了,也只能更新head为p了。
                 */
                if (p != h)
                    updateHead(h, ((q = p.next) != null) ? q : p);
                return item;
            }
            /*
             * 如果没能成功移除p，且p也没有后继，则说明p为此时队列的最后元素。
             * 所以更新head为p并返回null。
             *
             * 注意这里h和p是可能相等的，updateHead会判断h和p是否相等以避免无意义CAS。
             */
            else if ((q = p.next) == null) {
                updateHead(h, p);
                return null;
            }
            /*
             * p存在后继，需要检查是否p还在队列中。
             * 如果p已经不在队列中(p==q)，则重新读一次head到快照h并让p从h开始再尝试移除元素。
             *
             * 因为一定有其它线程已经通过updateHead将head从p给CAS为新的head并且令p节点的next指向p自己，
             * 这时再一步步往后面走显然不值得，不如从现在的head开始重新来过。
             */
            else if (p == q)
                continue restartFromHead;
            // 继续向后走一个节点尝试移除元素。
            else
                p = q;
        }
    }
}

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

3.3.3 peek方法

public E peek() {
restartFromHead:
    for (;;) {
        for (Node<E> h = head, p = h, q;;) {
            E item = p.item;
            // 其实这里的if就是将poll中的if前两个分支做了个合并。
            if (item != null || (q = p.next) == null) {
                updateHead(h, p);
                return item;
            }
            else if (p == q)
                continue restartFromHead;
            else
                p = q;
        }
    }
}

3.3.4 remove方法

public boolean remove(Object o) {
    if (o != null) {
        Node<E> next, pred = null;
        // p为当前节点，pred为p前驱，next为后继。
        for (Node<E> p = first(); p != null; pred = p, p = next) {
            boolean removed = false;
            E item = p.item;
            // item为null代表元素已经无效（认为不在队列中）
            if (item != null) {
                // 不是要删除的元素。
                if (!o.equals(item)) {
                    next = succ(p);
                    continue;
                }
                removed = p.casItem(item, null);
            }

            next = succ(p);
            if (pred != null && next != null)
                // 前驱与后继连上。
                pred.casNext(p, next);
            if (removed)
                return true;
        }
    }
    return false;
}

3.3.5 size方法

/**
 * size方法效率其实挺差的，是一个O(n)的遍历。
 */
public int size() {
    int count = 0;
    for (Node<E> p = first(); p != null; p = succ(p))
        if (p.item != null)
            // 最多只返回Integer.MAX_VALUE
            if (++count == Integer.MAX_VALUE)
                break;
    return count;
}

/**
 * 这个方法和poll/peek方法差不多，只不过返回的是Node而不是元素。
 *
 * 之所以peek方法没有复用first方法的原因有2点
 * 1. 会增加一次volatile读
 * 2. 有可能会因为和poll方法的竞争，导致出现非期望的结果。
 *    比如first返回的node非null，里面的item也不是null。
 *    但是等到poll方法返回从first方法拿到的node的item的时候，item已经被poll方法CAS为null了。
 *    那这个问题只能再peek中增加重试，这未免代价太高了。
 *
 * 这就是first和peek代码没有复用的原因。
 */
Node<E> first() {
restartFromHead:
    for (;;) {
        for (Node<E> h = head, p = h, q;;) {
            boolean hasItem = (p.item != null);
            if (hasItem || (q = p.next) == null) {
                updateHead(h, p);
                return hasItem ? p : null;
            }
            else if (p == q)
                continue restartFromHead;
            else
                p = q;
        }
    }
}