Java多线程 -- JUC包源码分析10 -- ConcurrentLinkedQueue源码分析

在前面的篇章中，我们详细分析了AQS，并提到了里面一个关键数据结构：所有阻塞线程组成的一个等待队列，这个队列是用单向无锁链表实现的。

今天所讲的ConcurrentLinkedQueue，其实现和AQS中的无锁队列基本一样。所以，如果你深刻理解了AQS，ConcurrentLinkedQueue也就知道了。出于内容的完整性，在此还是列一下其源码：

public class ConcurrentLinkedQueue<E> extends AbstractQueue<E>
implements Queue<E>, java.io.Serializable {

//单向链表的Node
private static class Node<E> {
private volatile E item;
private volatile Node<E> next;```
        。。。
    }

//整个队列记录1头1尾2个结点
private transient volatile Node<E> head = new Node<E>(null);
private transient volatile Node<E> tail = head;

//入队，也即cas tail (乐观锁）
public boolean offer(E e) {
if (e == null) throw new NullPointerException();
        Node<E> n = new Node<E>(e);
        retry:
for (;;) {
            Node<E> t = tail;
            Node<E> p = t;
for (int hops = 0; ; hops++) {
                Node<E> next = succ(p);
if (next != null) {
if (hops > HOPS && t != tail)
continue retry;
                    p = next;
                } else if (p.casNext(null, n)) {
if (hops >= HOPS)
                        casTail(t, n); // Failure is OK.
return true;   
                } else {
                    p = succ(p);
                }
            }
        }
    }

//出队，cas head，乐观锁
public E poll() {
        Node<E> h = head;
        Node<E> p = h;
for (int hops = 0; ; hops++) {
            E item = p.getItem();

if (item != null && p.casItem(item, null)) {
if (hops >= HOPS) {
                    Node<E> q = p.getNext();
                    updateHead(h, (q != null) ? q : p);
                }
return item;
            }
            Node<E> next = succ(p);
if (next == null) {
                updateHead(h, p);
break;
            }
            p = next;
        }
return null;
    }

   。。。
}