ConcurrentLinkedQueue学习

最新推荐文章于 2024-05-27 19:28:49 发布

原创最新推荐文章于 2024-05-27 19:28:49 发布 · 321 阅读

0 ·

CC 4.0 BY-SA版权

多线程/并发专栏收录该内容

5 篇文章

订阅专栏

本文详细介绍了ConcurrentLinkedQueue的工作原理及其内部实现机制。包括如何通过CAS算法保证线程安全，以及添加和获取元素的具体流程。

队列的概念

队列是一种先进先出的基于结点的数据结构，进入队列时间长的元素称之为队头，即head。进入队列时间最晚的元素称之为队尾，即tail。每次插入新的元素都是从队列的尾部插入。每次从队列中获取元素都是从头元素获取。
在JAVA中普通的队列Queue是线程非安全的数据结构，每次只有一个线程进行操作时才是安全的。然而，ConcurrentLinkedQueue属于线程安全的队列，支持多个线程并发操作。ConcurrentLinkedQueue如同其他并发框架一样，其中元素不能为空。
ConcurrentLinkedQueue是一种非阻塞队列，采用CAS算法实现。

Queue

Queue是队列的父接口，继承Collection接口。定义了Queue的各种行为：

public interface Collection<E> extends Iterable<E> {
     /**
     **往队列中添加一个元素，如果队列没有容量限制时，一直返回true
     **/
     boolean add(E e);
      /**
     **往队列中添加一个元素，如果队列没有容量限制时，一直返回true.
     **如果队列容量有限制，建议使用add方法；当对列满时，抛出异常
     **/
     boolean offer(E e);
     /**
     **获取队列中的head元素并从队列中删除head元素；如果队列为空，则抛出异常
     **/
     E remove();
      /**
     **获取队列中的head元素并从队列中删除head元素；如果队列为空，则返回NULL
     **/
     E poll();
     /**
     **返回队列中的head元素，如果队列为空则抛出异常
     **/
     E element();
     /**
     **返回队列中的head元素，如果队列为空则返回Null
     **/
     E peek();
}

内部数据结构

ConcurrentLinkedQueue内部定义了一个内部类Node，使用Node表示底层的链表结构。其中Node表示链表节点。程序中使用的共享变量都存放在节点的元素中。分析源码更有说服力：

 private static class Node<E> {
        // 对象存储在E中
        volatile E item;
        // 节点的引用，看出该队列是单向队列
        volatile Node<E> next;

        /**
         * Constructs a new node.  Uses relaxed write because item can
         * only be seen after publication via casNext.
         */
        Node(E item) {
            UNSAFE.putObject(this, itemOffset, item);
        }

        boolean casItem(E cmp, E val) {
            return UNSAFE.compareAndSwapObject(this, itemOffset, cmp, val);
        }

        void lazySetNext(Node<E> val) {
            UNSAFE.putOrderedObject(this, nextOffset, val);
        }

        boolean casNext(Node<E> cmp, Node<E> val) {
            return UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);
        }

        // Unsafe mechanics

        private static final sun.misc.Unsafe UNSAFE;
        private static final long itemOffset;
        private static final long nextOffset;

        static {
            try {
                UNSAFE = sun.misc.Unsafe.getUnsafe();
                Class k = Node.class;
                itemOffset = UNSAFE.objectFieldOffset
                    (k.getDeclaredField("item"));
                nextOffset = UNSAFE.objectFieldOffset
                    (k.getDeclaredField("next"));
            } catch (Exception e) {
                throw new Error(e);
            }
        }
    }

ConcurrentLinkedQueue

并发队列中定义了头节点head，尾节点tail。在实例化ConcurrentLinkedQueue时，头节点head和尾节点tail中的元素都是空的。并且指向同一个节点。

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

offer添加元素过程

ConcurrentLinkedQueue队列添加元素的过程，可以根据下图的过程来解释。
- 初始化ConcurrentLinkedQueue：head节点和tail节点都为空节点，指向同一个空节点。即节点中没有存储任何对象。
- 添加元素1(node1)：往链表中添加元素，首先要定位尾节点，第一次添加元素时tail节点即是尾节点。直接将Node1添加到尾节点即可。此时tail节点仍然指向最开始的空节点，没有指向Node1节点。此时，尾节点是node1节点。
- 添加元素2(node2)：每次往队列中添加元素都要首先定位尾节点。添加元素1时，尾节点是node1,而不是tail节点。先将node2添加到node1节点的后面，由于tail节点距离尾节点距离大于1个节点的步长，需要将tail节点设置成尾节点。(分析源码可以得到，后面分析)。此时tail节点的引用指向node2节点对象，tail节点不是空节点。
- 添加元素3(node3):此时tail节点是尾节点，直接将node3节点加入到node2节点后面，现在变成node3节点是尾节点，tail节点还是指向node2节点。
- 添加元素4(node4):添加元素4的过程跟添加元素2过程一样。都是先定位到尾节点node3，将Node4节点添加到尾部，此时tail节点与尾节点步长大于1个节点，需要将tail节点设置为尾节点。
offer源码分析

 public boolean offer(E e) {
        checkNotNull(e);
        // 添加一个新元素，实例化一个新节点newNode
        final Node<E> newNode = new Node<E>(e);
        // 每次添加都是先定位tail节点是否是尾节点
        // 新加入元素都要加入到原尾节点的后面
        for (Node<E> t = tail, p = t;;) {
            Node<E> q = p.next;
             // 如果tail是尾节点，则q必定为空
            if (q == null) {
              // 将newNode设置为当前链表的尾节点
                if (p.casNext(null, newNode)) {
                    // 根据上面分析，只要tail节点与尾节点步长大于1，则  
                    //  需要将tail节点设置当前队列尾节点。
                    //  失败了，说明其他线程操作成功。
                    if (p != t) // hop two nodes at a time
                        casTail(t, newNode);  // Failure is OK.
                    return true;
                }
                // Lost CAS race to another thread; re-read next
            }
            else if (p == q)
                // We have fallen off list.  If tail is unchanged, it
                // will also be off-list, in which case we need to
                // jump to head, from which all live nodes are always
                // reachable.  Else the new tail is a better bet.
                p = (t != (t = tail)) ? t : head;
            else
                // 定位尾节点：当tail节点不是尾节点时，程序会执行到这儿。将p重新
                // 指向尾节点q。即p=p.next。因为tail与尾节点步长最大为1.
                p = (p != t && t != (t = tail)) ? t : q;
        }
    }

从整个添加元素过程分析可以看出，头节点head中一直是空节点，并没有存储任何元素。

poll获取元素过程

源码分析

 public E poll() {
        restartFromHead:
        for (;;) {
            for (Node<E> h = head, p = h, q;;) {
               // 第一次获取元素时，头节点元素为空。后面获取时也会发生为空的情况
                E item = p.item;
                // 如果不为空，则castItem将当前已经获取到元素的节点内容设置为空
                if (item != null && p.casItem(item, null)) {
                    // 头节点为空，从下一个节点成功获取到元素后，需要
                    // 更新头节点指向新的链表中下一个首节点。
                    // 头节点不为空的情况下，不需要更新头节点的指向，
                    if (p != h) // hop two nodes at a time
                        updateHead(h, ((q = p.next) != null) ? q : p);
                    return item;
                }
                // 头节点元素为空，判断头节点的next节点是否为空。
                else if ((q = p.next) == null) {
                    updateHead(h, p);
                    return null;
                }
                else if (p == q)
                    continue restartFromHead;
                // 头节点为空，重新定位获取元素的指针位置
                else
                    p = q;
            }
        }
    }