Java源码解读系列7—ConcurrentLinkedQueue（JDK1.8 ）

1 概述

ConcurrentLinkedQueue（简称CLQ队列）是Queue接口的实现类，是一种无界、非阻塞、线程安全的FIFO队列。CLQ底层存储基于链表，头节点为哨兵节点，里面的数据域（item）为空。插数据时从尾节点插入，取数据时从头节点获取。相对于LinkedBlockingqueue（简称LBQ队列）采用读写各一把锁的机制保证线程安全，CLQ队列采用自旋+CAS机制实现无锁非阻塞。无论是同时有又多个生产者，还是多个消费者，都不会发生线程阻塞，遇到插入失败或者取数据失败的线程就会继续自旋，直到成功为止。

2 链表节点

 private static class Node<E> {
        //存储当前节点的元素
        volatile E item;
        //指向下一个链节点
        volatile Node<E> next;

        //构造函数
        Node(E item) {
            UNSAFE.putObject(this, itemOffset, item);
        }

       //通过CAS机制更新当前节点item中保存的元素
        boolean casItem(E cmp, E val) {
            return UNSAFE.compareAndSwapObject(this, itemOffset, cmp, val);
        }
        
       //通过putOrderedObject直接修改next的值
        void lazySetNext(Node<E> val) {
            UNSAFE.putOrderedObject(this, nextOffset, val);
        }
        
         //通过CAS机制更新下一个节点
        boolean casNext(Node<E> cmp, Node<E> val) {
            return UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);
        }
        ...

3 构造函数

分为有参构造函数和无参构造函数两种。有参构造函数就是传入一个Collection接口的实现类，将集合里面的元素转换为CLQ队列元素，比较简单，这里不展开。
无参构造函数是给CLA的全局head和tail引用初始化，两者指向一个相同的节点，里面的item为空。

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

4 新增操作（add方法和offer方法）

4.1 add方法

CLQ的add方法实质上是调用offer方法

public boolean add(E e) {
        return offer(e);
 }

4.2 图解offer方法

在CLQ的添加方法中，最重要一个原则就是添加任务执行完后，tail引用不一定指向链表最尾节点。
offer方法不好理解，需要结合取出方法，这里可以先看场景图，后面再对比研究
这里主要图解单线程，但是多线程场景也类似，无非是失败重试。

4.2.1 单线程连续执行两次offer操作

1) 插入前

head和tail指向相同节点Node1

2）第一次插入数据

offer(“data1”),此时p == t，但是tail没有指向尾节点

3）第二次插入数据

offer(“data2”),p寻找到真正的尾节点，将数据插入
p发现为节点和tail不是同一个节点，tail需要修正，通过casTail操作让tail重新指向尾节点

4.2.2 单线程执行offer-poll-offer操作

1) 插入前

head和tail指向相同节点Node1

2）第一次插入数据

offer(“data1”),此时p == t，但是tail没有指向尾节点

3）第一次删除

执行poll操作后，tail和p都指向Node1，但是Node1已经出队列，并且next指针指向自己

4）第二次插入数据

offer(“data2”),此时 走offer操作的条件else if (p == q)，让tail重新指向链表的头节点，p继续寻找尾节点进行插入操作

4.3 offer方法源码

public boolean offer(E e) {
       //非空检查
        checkNotNull(e);
        //新增节点
        final Node<E> newNode = new Node<E>(e);
        //t指向尾节点，将t赋值给p
        //在多线程环境，tail引用指向的未必是链表的最后一个节点，但是只有当p节点指向链表的的尾节点时，才会发生新node插入队列操作
        for (Node<E> t = tail, p = t;;) {
        //q的引入，是为了 1）判断p是否为尾节点 2）用来帮助将p向后移动
            Node<E> q = p.next;
            //如果q为空，说明p是尾节点
            if (q == null) {
               //执行CAS操作将newNode入队
               //多线程环境可能入队失败，因为有其他线程发送插入操作。
               //因为是非阻塞队列，所以插入失败不会阻塞当前线程，而是重新自旋
                if (p.casNext(null, newNode)) {
                    //插入成功，此时t节点可能和p不相等，因为tail节点不一定是指向尾节点
                    if (p != t) 
                    //使用CAS操作将tail指向新node节点
                    //多线程环境可能发生更新失败，因为其他线程可能又插入新的节点
                    //正是因为这个原因，tial不总指向链表最尾节点
                        casTail(t, newNode); 
                   //返回更新成功
                    return true;
                }       
            }
            
            //tail指向的节点被移除出链表，且tail指向的节点的next指针指向自己
            else if (p == q)
              //修正操作，将head赋值给p，让p重新去找尾节点
                p = (t != (t = tail)) ? t : head;
            else
                //检查tail节点是否位于为节点。如果不是，则将q赋值给p，即将p向后移动一个节点
                //本质上是在找尾节点，并把尾节点赋值给p
                p = (p != t && t != (t = tail)) ? t : q;
        }
    }
    
    
    //通过CAS操作将val节点更新为尾节点
     private boolean casTail(Node<E> cmp, Node<E> val) {
        return UNSAFE.compareAndSwapObject(this, tailOffset, cmp, val);
    }

5 取出操作(poll)

取出操作最重要原则就是头节点为哨兵节点，所以需要去找真正的数据节点，除非队列本身就为空

 public E poll() {
        restartFromHead:
        //自旋
        for (;;) {
        //h指向头节点，将h赋值给p
        //q的引入，是为了 1）判断链表是否已经到头了  2）用来帮助将p向后移动
            for (Node<E> h = head, p = h, q;;) {
                E item = p.item;
                
                //item不为空，说明p节点为真正的数据节点
                //指行CAS操作，将item值置为空，若失败说明有其他线程已经优先将item置为空。
                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
                        updateHead(h, ((q = p.next) != null) ? q : p);
                    return item;
                }
                //说明队列为空
                else if ((q = p.next) == null) {
                    updateHead(h, p);
                    return null;
                }
                //p节点指向的节点已经出队并且指向自身，此时第一轮 for (Node<E> h = head, p = h, q;;)循环操作失败，回到for (;;) 
                else if (p == q)
                    continue restartFromHead;
                else
                    //p节点向尾部移动
                    p = q;
            }
        }
    }

    //更新头节点
    final void updateHead(Node<E> h, Node<E> p) {
    //再次检查h是否
        if (h != p && casHead(h, p))
             //将h的下一个节点指向自己，提高GC效率
            h.lazySetNext(h);
    }

6 查询操作(peek方法)

调用peak方法，可以获取队列中的第一个值。跟取出操作很像，比取出操作简单，因为不需要将找到的item置为空。

 public E peek() {
        restartFromHead:
        //自旋
        for (;;) {
           //h指向头节点，将h赋值给p
           //q的引入，是为了 1）判断链表是否已经到头了  2）用来帮助将p向后移动
            for (Node<E> h = head, p = h, q;;) {
                E item = p.item;
                //找到第一个符合的节点
                if (item != null || (q = p.next) == null) {
                   //更新头节点
                    updateHead(h, p);
                    return item;
                }
                 //p节点指向的节点已经出队并且指向自身，此时第一轮 for (Node<E> h = head, p = h, q;;)循环操作失败，回到for (;;) 
                else if (p == q)
                    continue restartFromHead;
                else
                //p节点向尾部移动
                    p = q;
            }
        }
    }

7 参考文献

1）JDK7在线文档
https://tool.oschina.net/apidocs/apidoc?api=jdk_7u4
2) JDK8在线文档
https://docs.oracle.com/javase/8/docs/api/
3) Bruce Eckel. Java编程思想，第4版，2007，机械工业出版社
4）方腾飞，魏鹏，程晓明. Java并发编程的艺术，第1版，2015年，机械工业出版社