12张图一次性搞懂高性能并发容器ConcurrentLinkedQueue

【源创会预告】1024 程序员节（的前两天），相约开源中国办公室，我们一起聊 AI！>>>

12张图一次性搞懂高性能并发容器ConcurrentLinkedQueue

前言

上篇文章聊到并发集合CopyOnWeiteArrayList的实现与特点，其不足之处是不适合写多的场景也不适合并发量大的场景

本篇文章来聊聊并发场景下高性能的ConcurrentLinkedQueue

阅读本文大概需要10分钟

在阅读本文前，需要理解CAS、volatile等知识

如果不理解CAS可以查看这篇文章15000字、6个代码案例、5个原理图让你彻底搞懂Synchronized 的第二小节

如果不理解volatile可以查看这篇文章5个案例和流程图让你从0到1搞懂volatile关键字

数据结构

ConcurrentLinkedQueue从名称上来看就能够知道，它支持并发、由链表实现的队列

通过源码，我们可以看到ConcurrentLinkedQueue使用字段记录首尾节点、并且节点的实现是单向链表

并且这些关键字段都被volatile修饰，在读场景下使用volatile保证可见性，不用“加锁”

扫描二维码关注公众号，回复： 17112187 查看本文章

还有一些其他字段，比如使用CAS的Unsafe和一些偏移量信息等，这里就不一一列举

   public class ConcurrentLinkedQueue<E> extends AbstractQueue<E>
           implements Queue<E>, java.io.Serializable {    
   
       private static class Node<E> {
           //记录数据
           volatile E item;
           //后继节点
           volatile Node<E> next;
       }
       //首节点
       private transient volatile Node<E> head;
       //尾节点
       private transient volatile Node<E> tail;
   }

在初始化时，首尾节点会同时指向一个存储数据为空的节点

       public ConcurrentLinkedQueue() {
           head = tail = new Node<E>(null);
       }

设计思想

延迟更新首尾节点

在查看实现原理前，我们先来说说ConcurrentLinkedQueue的设计思想，否则实现原理可能会看不懂

ConcurrentLinkedQueue写场景中采用乐观锁的思想，使用CAS+失败重试来保证操作的原子性

为了避免CAS开销过大，ConcurrentLinkedQueue采用延迟更新首尾节点的思想，来减少CAS次数

也就是说ConcurrentLinkedQueue中的首尾节点并不一定是最新的首尾节点

哨兵节点

ConcurrentLinkedQueue的设计中使用哨兵节点

什么是哨兵节点？

哨兵节点又称虚拟节点，哨兵节点常使用在链表这种数据结构中

单向链表中如果要添加或者删除某个节点时，一定要获得这个节点的前驱节点再去进行操作

当操作的是第一个节点时，如果在第一个节点前面加个虚拟节点（哨兵节点），那么就不用特殊处理

换而言之使用哨兵节点可以减少代码复杂度，相信刷过链表相关算法的同学深有体会

哨兵节点还能够在只有一个节点时减少并发冲突

这一特点可能要看完后续实现和流程图才能理解

源码实现

ConcurrentLinkedQueue主要的操作是入队、出队，我们使用offer和poll来对其进行分析

offer

在分析源码前，先来说明一些复杂变量的作用

t记录尾节点tail

p用于循环遍历的节点，当p节点为真正尾节点时才允许添加新节点

q 用于记录p的后继节点

在入队时分三种情况：

当p的后继节点为空时（p为真正尾节点），尝试CAS增加新节点，成功后尝试更新尾节点tail
当p等于p的后继节点时（p的next指向自己，说明构建成哨兵节点，出队poll时可能构造哨兵节点）；此时判断尾节点是否被修改过，如果尾节点被修改过就定位到尾节点，如果未被修改过（使用next无法继续遍历），只能定位到头节点
其他情况时，说明此时的p并不是真正的尾节点，需要定位到真正尾节点；此时如果p不是原来的尾节点并且尾节点被修改过，那就定位到尾节点，否则定位到后继节点继续遍历

第二、三种情况的代码观赏性很好但是可读性不好，可以将总结的情况与源码分析一起观看，如果还是不理解后续有流程图方便理解

       public boolean offer(E e) {
           //检查空指针
           checkNotNull(e);
           //构建新节点
           final Node<E> newNode = new Node<E>(e);
           //失败重试的循环
           //t:当前记录的尾节点
           //p:真正的尾节点
           //q:p的后继节点
           for (Node<E> t = tail, p = t;;) {
               Node<E> q = p.next;
               //情况1：p的后继节点为空，说明当前p就是真正尾节点
               if (q == null) {
                   //尝试CAS修改p的后继节点为新节点
                   //如果p的next是null 则替换成新节点newNode
                   //失败则说明其他线程cas添加节点成功，继续循环；成功则判断是否更新尾节点tail
                   if (p.casNext(null, newNode)) {
                       //如果p不等于t 说明此时的尾节点不是真正的尾节点
                       //尝试CAS：如果当前尾节点是t，那么就将新节点设置成尾节点
                       if (p != t) 
                           casTail(t, newNode);  
                       return true;
                   }
                   
               }
               //情况2:p等于p的后继节点（p指向自己）
               else if (p == q)
                   //t：旧的尾节点
                   //(t = tail)：新的尾节点
                   //t != (t = tail): 说明尾节点被修改过，p等于新的尾节点；未被修改过，p等于头节点
                   p = (t != (t = tail)) ? t : head;
               
               //情况3：此时p不是真正尾节点，需要去定位真正尾节点
               else
                   //p!=t:p不再是原来的尾节点
                   //t != (t = tail):尾节点被修改过
                   //p不再是原来的尾节点 并且 尾节点被修改过 就让p等于修改过的尾节点；否则让p等于它的后继节点q
                   p = (p != t && t != (t = tail)) ? t : q;
           }
       }

poll

如果理解入队offer中的变量，那么出队poll也好理解，其中p和q都是类似的

h记录头节点head

p用于循环遍历的节点，当p节点为真正头节点时才允许出队

q 用于记录p的后继节点

出队的情况分为四种

当p为真正头节点时，CAS将数据设置为空，然后判断head是否为真正头节点，不是则更新头节点，然后将原来的头节点next指向它自己构建成哨兵节点
当p的后继节点为空时，说明队列为空，尝试CAS将头节点修改成p
如果p的后继节点是它自己，说明其他线程poll出队构建成哨兵节点，跳过本次循环
其他情况则向后遍历

      public E poll() {
          //方便退出双重循环
          restartFromHead:
          for (;;) {
              //h记录头节点
              //p真正头节点
              //q为p的后继节点
              for (Node<E> h = head, p = h, q;;) {
                  //获取p节点的数据
                  E item = p.item;
                  //情况1：
                  //如果数据不为空 说明p节点为真正头节点
                  //尝试CAS将数据设置为null,如果数据为item则替换为null，失败则说明其他线程以及出队，继续循环
                  if (item != null && p.casItem(item, null)) {
                      //如果当前头节点不是真正头节点则更新头节点
                      if (p != h) 
                          updateHead(h, ((q = p.next) != null) ? q : p);
                      return item;
                  }
                  //情况2：
                  //p的后继节点为空，说明当前为空队列，尝试CAS将头节点修改为p（p此时可能是哨兵节点）
                  else if ((q = p.next) == null) {
                      updateHead(h, p);
                      return null;
                  }
                  //情况3:
                  //如果p的后继节点指向p自己，说明其他线程poll出队时构建成哨兵节点，跳过本次循环
                  else if (p == q)
                      continue restartFromHead;
                  //情况4:
                  //p定位为后继节点需要遍历
                  else
                      p = q;
              }
          }
      }

在更新头节点方法中，会进行判断

如果当前头节点不是真正头节点，则尝试CAS将头节点设置成p真正头节点

CAS成功后将原来的头节点的next指向它自己，构建成哨兵节点

 final void updateHead(Node<E> h, Node<E> p) {
     if (h != p && casHead(h, p))
         h.lazySetNext(h);
 }

流程图实现

想要跟着debug的同学，需要把idea中的这两个设置关闭，否则debug会有误

为了更容易的理解，我们来看一段简单的代码，并附带其实现流程图

     public void testConcurrentLinkedQueue()  {
         ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();
 
         queue.offer("h1");
         queue.offer("h2");
         queue.offer("h3");
 
         String p1 = queue.poll();
         String p2 = queue.poll();
         String p3 = queue.poll();
         String p4 = queue.poll();
 
         queue.offer("h4");
         System.out.println(queue);
     }