ConcurrentLinkedQueue源码分析

private transient volatile Node<E> head;
private transient volatile Node<E> tail;

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实际上指向尾节点
           if (q == null) { //尾节点下一个为null
               // p is last node
               if (p.casNext(null, newNode)) { //CAS插入
                   // Successful CAS is the linearization point
                   // for e to become an element of this queue,
                   // and for newNode to become "live".
                   if (p != t) //tail之后至少有两个节点才修改tail
                       casTail(t, newNode);  // CAS替换尾节点
                   return true;
               }
               // Lost CAS race to another thread; re-read next
           }
           else if (p == q)//p节点指向自身，说明p是自链节点
               // 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.
               //如果tail节点被其它线程修改，此时需要从head节点开始向
               //后遍历，因为从head开始可达所有的live节点
               p = (t != (t = tail)) ? t : head;
           else
               // Check for tail updates after two hops.
               //继续向后查找，如果tail节点变化，重新获取tail。
               p = (p != t && t != (t = tail)) ? t : q;
       }
   }

public E poll() {
       restartFromHead:
       for (;;) {
       //从head开始先后查找第一个live节点
           for (Node<E> h = head, p = h, q;;) {
               E item = p.item;

               if (item != null && p.casItem(item, null)) {
               //找到第一个不为null的节点，通过CAS设置item为null
                   // Successful CAS is the linearization point
                   // for item to be removed from this queue.
                   if (p != h) // 跳两个以上的节点才修改head
                       updateHead(h, ((q = p.next) != null) ? q : p);
                   return item;
               }
               else if ((q = p.next) == null) { //队列已空
                   updateHead(h, p);//CAS修改head为p
                   return null;
               }
               else if (p == q) //p为自链节点，重新获取head循环
                   //跳转到restartFromHead继续循环
                   continue restartFromHead; 
               else
                   p = q; //先后查找
           }
       }
   }