ConcurrentLinkedQueue (一）

ConcurrentLinkedQueue

主要讲一下在JDK8中，ConcurrentLikedQueue是如何入队，出队的。

首先我们要明白，ConcurrentLikedQueue是一种安全的没有边界的基于链表的队列，有头节点head,尾结点tail。

类似于           ，上图是创建一个空的队列，只有head和tail节点，以下为源码：

public ConcurrentLinkedQueue() {
        head = tail = new Node<E>(null);
}

对于入队来说，我们要了解的是tail节点不一定是最后一个节点，这是非常重要的。一般来说，当tail节点的next不为空时，在队尾加入新节点，更新tail指向尾节点；当tail的next节点为空时，在队尾加入新节点,不更新tail的位置。

源码中有一个注释：Both head and tail are permitted to lag.  In fact, failing to update them every time one could is a significant optimization (fewer CASes). As with LinkedTransferQueue (see the internal documentation for that class), we use a slack threshold of two; that is, we update head/tail when the current pointer appears to be two or more steps away from the first/last node.
 大概的意思是说不用每次都更新头尾节点，这是一个非常重要的优化。 使用的松弛阈值为2; 也就是说，当当前指针距离第一个/最后一个节点有两个或更多节点的距离时，我们更新head/tail。

在入队的时候，我们就能够很容易的看到上述所描述tail的特点。

入队：

 /**
      * Inserts the specified element at the tail of this queue.
      * As the queue is unbounded, this method will never return {@code false}.
      * 将指定的元素插入到此队列的末尾。因为队列是无界的，所以这个方法永远不会返回{@code false}。

      * @return {@code true} (as specified by {@link Queue#offer})
      * @throws NullPointerException if the specified element is null
      */
     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) {   //tail是尾结点
                 // p is last node
                 //如果p是尾结点，设置p节点的next为newNode
                 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".
                     //成功的CAS是使e成为这个队列的一个元素，使newNode成为“活的”的线性化点。
                     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
                 //丢失的CAS争用到另一个线程;重读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;
         }
     }

上述的offer(E e)方法，即是向队列尾部添加元素。

首先，入队前构建结点newNode,接下来无限for循环，保证入队成功，所以该方法返回总是true。

假设现在队列中有两个结点a,b,tail指向b。t->tail,p->t，如下图：

假设现在要添加一个c结点，那么会出现下图情况：

如果再添加一个D结点，

（1）因为p结点的后继结点q不为null,并且q也不等于p,所以经过判断后，p指向q,tail不变。如下图：

（2）q继续指向p的next结点，因为q为null,所以把d结点设置为p结点的next结点，因为p不指向t,所以把t指向为尾结点。如下图：

总结下来，我们发现，首先总会获取到尾结点，然后用CAS算法进行结点入队。