实现并发安全有两种方式：一种是阻塞式的：例如：LinkedBlockingQueue;另一种是非阻塞式的：例如：ConcurrentLinkedQueue,非阻塞式的最显著的优点是性能，非阻塞式算法使用CAS原子性来更新数据。避免了加锁的时间，同时也保证了数据的一致性。

1.ConcurrentLinkedQueue简介

ConcurrentLinkedQueue中包含两个内部类，Node<E>和Itr。Node<E>表示ConcurrentLinkedQueue链表中的一个节点；Itr类用来遍历ConcurrentLinkedQueue。

2.常用方法

2.1offer()

public boolean offer(E e) {
    if (e == null) throw new NullPointerException();
    //入队前，创建一个入队节点
    Node<E> n = new Node<E>(e);
    retry:
    //死循环，入队不成功反复入队。
    for (;;) {
        //创建一个指向tail节点的引用
        Node<E> t = tail;
        //p用来表示队列的尾节点，默认情况下等于tail节点。
        Node<E> p = t;
        for (int hops = 0; ; hops++) {
        //获得p节点的下一个节点。
            Node<E> next = succ(p);
        //next节点不为空，说明p不是尾节点，需要更新p后在将它指向next节点
            if (next != null) {
               //循环了两次及其以上，并且当前节点还是不等于尾节点
                if (hops > HOPS && t != tail)
                    continue retry; 
                p = next;
            } 
            //如果p是尾节点，则设置p节点的next节点为入队节点。
            else if (p.casNext(null, n)) {
              //如果tail节点有大于等于1个next节点，则将入队节点设置成tair节点，更新失败了也
没关系，因为失败了表示有其他线程成功更新了tair节点。
                if (hops >= HOPS)
                    casTail(t, n); // 更新tail节点，允许失败
                return true;  
            } 
           // p有next节点,表示p的next节点是尾节点，则重新设置p节点
            else {
                p = succ(p);
            }
        }
    }
}

上面代码的设计原理有两点，1.定位出尾节点；2.使用CAS将入队节点设置成尾节点的next节点。

2.2poll

public E poll() {
    Node<E> h = head;
   // p表示头节点，需要出队的节点
    Node<E> p = h;
    for (int hops = 0;; hops++) {
        // 获取p节点的元素
        E item = p.getItem();
        // 如果p节点的元素不为空，使用CAS设置p节点引用的元素为null,如果成功则返回p节点的元素。
        if (item != null && p.casItem(item, null)) {
            if (hops >= HOPS) {
                //将p节点下一个节点设置成head节点
                Node<E> q = p.getNext();
                updateHead(h, (q != null) ? q : p);
            }
            return item;
        }
        // 如果头节点的元素为空或头节点发生了变化，这说明头节点已经被另外一个线程修改了。那么获取p节点的下一个节点 
        Node<> next = succ(p);
        // 如果p的下一个节点也为空，说明这个队列已经空了
        if (next == null) {
          // 更新头节点。
            updateHead(h, p);
            break;
        }
        // 如果下一个元素不为空，则将头节点的下一个节点设置成头节点
        p = next;
    }
    return null;
}

首先获取头结点的值，然后判断头结点元素是否为空，如果为空，就表示另一个线程已经进行了一次出队的操作，如果不为空，则使用CAS将头结点的引用设置为空，如果CAS成功，直接返回头结点的元素，如果不成功，另外一个线程已经完成了出队操作并跟新了head元素，，需要重新获取头结点。

2.3remove

public boolean remove(Object o) {  
        if (o == null) return false;  
        Node<E> pred = null;  
        // 这里是从head 开始的，中间还涉及到head 的判断等从操作  
        // 跟一般for 循环类似，要遍历的- -，这样的操作o 很靠后的时候，会慢- -！  
        // - -不太喜欢这方法，了解作用  
        for (Node<E> p = first(); p != null; p = succ(p)) {  
            E item = p.item;  
            if (item != null &&  
                    o.equals(item) &&  
                    p.casItem(item, null)) {  
                Node<E> next = succ(p);  
                if (pred != null && next != null)  
                    pred.casNext(p, next);  
                return true;  
            }  
            pred = p;  
        }  
        return false;  
    }