ConcurrentLinkedQueue
    单向链表
    无锁的，通过CAS来实现线程安全，不用切换线程上下文，但是再并发大的时候会导致线程一直自旋使CPU飙高
    内部维护了一个head和一个tail两个node节点，其中再添加元素的时候tail节点不是每次添加玩都会去移动，是每入队两次tail才移动一次,这样减少了tail的移动次数，tail.next == null 那么tail就是真正的尾节点（如果tail直接指向尾节点的话因为设置tail是CAS操作，性能上不如两次移动一次）

    1.     public boolean offer(E e) {
    2.         checkNotNull(e);
    3.         final Node<E> newNode = new Node<E>(e);
    5.         for (Node<E> t = tail, p = t;;) {
    6.             Node<E> q = p.next;
    7.             if (q == null) {
    8.                 // p is last node
    9.                 if (p.casNext(null, newNode)) {
    10.                     // Successful CAS is the linearization point
    11.                     // for e to become an element of this queue,
    12.                     // and for newNode to become "live".
    13.                     if (p != t) // hop two nodes at a time
    14.                         // 这里设置移动tail节点，第一次p == t 就不会设置tail节点
    15.                         casTail(t, newNode);  // Failure is OK.
    16.                     return true;
    17.                 }
    18.                 // Lost CAS race to another thread; re-read next
    19.             }
    20.             else if (p == q) // p.next = p 并发下可能会p.next = p
    21.                 // We have fallen off list.  If tail is unchanged, it
    22.                 // will also be off-list, in which case we need to
    23.                 // jump to head, from which all live nodes are always
    24.                 // reachable.  Else the new tail is a better bet.
    25.                 p = (t != (t = tail)) ? t : head;
    26.             else
    27.                 // Check for tail updates after two hops.
    28.                 p = (p != t && t != (t = tail)) ? t : q;
    29.         }
    30.     }