ConcurrentLinkedQueue解析

    private transient volatile Node<E> tail;
    /**
     * Creates a {@code ConcurrentLinkedQueue} that is initially empty.
     */
    public ConcurrentLinkedQueue() {
        head = tail = new Node<E>(null);
    } 

public boolean offer(E e) {
        checkNotNull(e);
        //创建一个新的入队节点
        final Node<E> newNode = new Node<E>(e);
     //t是一个指向tail的引用，p用来表示队列的尾节点，开始默认p等于tail
        for (Node<E> t = tail, p = t;;) {
            Node<E> q = p.next;//q是尾节点p的下一个节点
            if (q == null) { //说明p是尾节点
                // 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".
                 //如果p和tail引用p不同，说明引用t指向的节点不是最新尾节点，让t指向最新的节点
                    if (p != t) // hop two nodes at a time
                      //更新tail节点引用，允许失败
                        casTail(t, newNode);  // Failure is OK.
                    return true;  //更新结束
                }
                // Lost CAS race to another thread; re-read next
            }
            else if (p == q)  //说明p节点和其尾节点都是null,这表明这个队列刚刚初始化，因此返回head节点
                // 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.
         //这个条件表达式看着好复杂，看看(t != (t = tail)) 先赋值再判断不等，一直都是false,疑问为嘛不直接p=head
                p = (t != (t = tail)) ? t : head;
            else
                // Check for tail updates after two hops.
             //这里同上，为嘛不直接p=q;
                p = (p != t && t != (t = tail)) ? t : q;
        }
    }  

在jdk1.6,入队列操作是用hops来进行控制更新tail次数的，偶的运行环境是1.7，所以代码如上，感觉没有对tail进行cas更新距离的限制，上面分析过对于先进先出的队列入队所要做的事情就是将入队节点设置成尾节点，doug lea写的代码和逻辑还是稍微有点复杂。那么我用以下方式来实现行不行？

public boolean offer(E e) {
        if (e == null)
            throw new NullPointerException();
        Node<E> n = new Node<E>(e);
        for (;;) {
            Node<E> t = tail;
            if (t.casNext(null, n) && casTail(t, n)) {
                return true;
            }
        }
    }

让tail节点永远作为队列的尾节点，这样实现代码量非常少，而且逻辑非常清楚和易懂。但是这么做有个缺点就是每次都需要使用循环CAS更新tail节点。如果能减少CAS更新tail节点的次数，就能提高入队的效率，所以doug lea使用hops变量来控制并减少tail节点的更新频率，并不是每次节点入队后都将 tail节点更新成尾节点，而是当 tail节点和尾节点的距离大于等于常量HOPS的值（默认等于1）时才更新tail节点，tail和尾节点的距离越长使用CAS更新tail节点的次数就会越少，但是距离越长带来的负面效果就是每次入队时定位尾节点的时间就越长，因为循环体需要多循环一次来定位出尾节点，但是这样仍然能提高入队的效率，因为从本质上来看它通过增加对volatile变量的读操作来减少了对volatile变量的写操作，而对volatile变量的写操作开销要远远大于读操作，所以入队效率会有所提升。

 public E poll() {
        restartFromHead:
        for (;;) {
         //开始h指向head，p表示头结点，需要出队的节点
            for (Node<E> h = head, p = h, q;;) {
                E item = p.item;
                //p节点里面有元素项，则直接出该元素项，并将p元素项CAS更新为NUll 
                if (item != null && p.casItem(item, null)) {
                    // Successful CAS is the linearization point
                    // for item to be removed from this queue.
                    if (p != h) // hop two nodes at a time
                        //p不为h的时候说明h还在前一个项为NUll的位置，而p在后一个有项item的位置，则更新h指向
                        //若p的后驱不为null,则将h指向p的后驱，因为当前p的项也是要出队的
                        //若p的后驱为NUll,则将h指向p，此时他们的item都为Null
                        updateHead(h, ((q = p.next) != null) ? q : p);
                    return item;
                }
                else if ((q = p.next) == null) {//此时p.item=null的
                  //p的后驱为null，用P更新h值
                    updateHead(h, p);
                    return null;//所以返回NUll
                }
                else if (p == q)
                    continue restartFromHead; /继续循环for
                else
                    p = q;//q在p后面，p中节点已经出队，则让p指向q
            }
        }
    }