CoucurrentLinkedQueue学习笔记

1.ConcurrentLinkedQueue是一个基于链接节点的无边界的线程安全队列，它采用FIFO原则对元素进行排序。采用“wait-free”算法（即CAS算法）来实现的。

2.CoucurrentLinkedQueue的结构由head节点和tail节点组成，每个节点由节点元素item和指向下一个节点的next引用组成，而节点与节点之间的关系就是通过该next关联起来的，从而组成一张链表的队列。节点Node为ConcurrentLinkedQueue的内部类。

private static class Node<E> {
        /** 节点元素域 */
        volatile E item;
        volatile Node<E> next;
        ......
    }

3.CoucurrentLinkedQueue队列的入列操作。

public boolean offer(E e) {
        //检查节点是否为null
        checkNotNull(e);
        // 创建新节点
        final Node<E> newNode = new Node<E>(e);

        //循环,直到成功为止
        for (Node<E> t = tail, p = t;;) {
            Node<E> q = p.next;
            // q == null 表示 p已经是最后一个节点了，尝试加入到队列尾
            // 如果插入失败，则表示其他线程已经修改了p的指向
            if (q == null) {                                
                // casNext：t节点的next指向当前节点
                // casTail：设置tail 尾节点
                if (p.casNext(null, newNode)) {             
                    // node加入节点后t节点就已经不是尾节点了，更新tail节点
                    if (p != t)                             
                        casTail(t, newNode);                  
                    return true;
                }
            }
            // p == q 等于自身
            else if (p == q)                               
                // p == q 代表着该节点已经被删除了
                // 由于多线程的原因，我们offer()的时候也会poll()，如果offer()的时候正好该节点已经poll()了
                // 那么在poll()方法中的updateHead()方法会将head指向当前的q，而把p.next指向自己，即：p.next == p,在多线程环境下此时就会导致p==q
                // 这时tail节点滞后head（tail位于head的前面），则需要重新设置p
                p = (t != (t = tail)) ? t : head;          
            // tail并没有指向尾节点
            else
                // tail已经不是最后一个节点，将p指向最后一个节点
                p = (p != t && t != (t = tail)) ? t : q;  
        }
    }

4.CoucurrentLinkedQueue队列的出列操作。

public E poll() {
        // 如果出现p被删除的情况需要从head重新开始,这时java的continue标签语法
        restartFromHead:
        for (;;) {
            for (Node<E> h = head, p = h, q;;) {

                // 节点 item
                E item = p.item;

                // item 不为null，则将item 设置为null
                if (item != null && p.casItem(item, null)) {           
                    // p != head 则更新head
                    if (p != h)                                                
                        // p.next != null，则将head更新为p.next ,否则更新为p
                        updateHead(h, ((q = p.next) != null) ? q : p);       
                    return item;
                }
                // p.next == null 队列为空
                else if ((q = p.next) == null) {                      
                    updateHead(h, p);
                    return null;
                }
                // 当一个线程在poll的时候，另一个线程已经把当前的p从队列中删除——将p.next = p，p已经被移除不能继续，需要重新开始
                else if (p == q)                                       
                    continue restartFromHead;
                else
                    p = q;                                     
            }
        }
    }

5.CoucurrentLinkedQueue允许head和tail更新滞后。以tail为例，一般来说我们期望tail总是作为链表的末尾，但实际上tail的更新并不是及时的，可能会产生拖延现象。就是说，有可能指向的并不是真正的尾巴，真正的可能在后面一个或者多个。

6.线程安全完全由CAS操作和队列的算法来保证。

7.几个特点。

(1)在入队的最后一个元素的next为null

(2)队列中所有未删除的节点的item都不能为null且都能从head节点遍历到

(3)对于要删除的节点，不是直接将其设置为null，而是先将其item域设置为null（迭代器会跳过item为null的节点）

(4)允许head和tail更新滞后。即head、tail不总是指向第一个元素和最后一个元素。