jdk源码阅读-ConcurrentLinkedQueue(一)

说明

concurrentLinkedQueue为无界非阻塞队列,是线程安全的 内部结构为链表的形式, 内部使用cas保存线程安全。采用cas保证原子性

什么是CAS

CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。 如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值 。否则，处理器不做任何操作

AtomicInteger例子

 AtomicInteger atomicInteger=new AtomicInteger();
//内部通过CAS保证原子性
 atomicInteger.getAndIncrement();

  private static final Unsafe unsafe = Unsafe.getUnsafe();
  public final int getAndIncrement() {
     return unsafe.getAndAddInt(this, valueOffset, 1);
  }

   public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
            /**
             * var1为对象  var2 为对象内存中的属性值  var5 为期望值  var4为修改后的值 如果cas失败则继续重试
             * 从内存中取出var1对象的var2的值为内存值
             */
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }

注意:Unsafe是c++实现的 遗憾的是这个类是jdk专用 我们并不能使用

ConcurrentLinkedQueue类图

 并没有实现BlockingQueue所以是并不是阻塞队列  同时也不适合使用线程池  并发情况下队列会无线扩张 会导致内存溢出 以及线程池的maximumPoolSize 参数无效

详情看:https://www.cnblogs.com/LQBlog/p/8735356.html#autoid-1-0-0

源码

核心属性

    /**
     * 头节点
     */
    private transient volatile ConcurrentLinkedQueue.Node<E> head;

    /**
     * 尾节点
     */
    private transient volatile ConcurrentLinkedQueue.Node<E> tail;

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

从尾部入队 从头部出队  都用volatile修饰 表示多线程修改 其中一个线程修改 会立即刷新到主内存 对其他线程立即可见

Node源码

    private static class Node<E> {
        //当前元素值
        volatile E item;
        //下一个节点元素
        volatile ConcurrentLinkedQueue.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(ConcurrentLinkedQueue.Node<E> val) {
            UNSAFE.putOrderedObject(this, nextOffset, val);
        }

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

        // Unsafe mechanics

        private static final sun.misc.Unsafe UNSAFE;
        //偏移量 cas
        private static final long itemOffset;
        //便宜量
        private static final long nextOffset;

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

item 和next都是volatile修饰

几个原则

1.next和head属性都不会为null 就算队列中一个元素也没有也会同时指向同一个空节点

2.head和tail刷新并不是实时的

3.head并不一定是真正的头节点 tail并不一定是尾节点

4.tail.next=null一定是尾节点

offer源码

    public boolean add(E e) {
        return offer(e);
    }
    public boolean offer(E e) {
        //1.检查是否为空 空元素不允许入队
        checkNotNull(e);
        //2.创建node节点包装类
        final ConcurrentLinkedQueue.Node<E> newNode = new ConcurrentLinkedQueue.Node<E>(e);
        //3映射cas修改失败重新查找尾节点的遍历重试  以及多线程并发修改 和tail不是真正未接节点的 真正尾节点查找
        for (ConcurrentLinkedQueue.Node<E> t = tail, p = t; ; ) {
            ConcurrentLinkedQueue.Node<E> q = p.next;
            /**
             * 3.q等于null代表为最后一个节点
             *    映射代码5的延迟修改tail
             *    映射代码6的cas修改并不是一定成功也没采取重试
             *    映射多线程有其他线程抢先入队
             */
            if (q == null) {
                /**
                 *  4.cas更新 底层使用Unsafe c++实现 直接调度cpu指令实现 cas更新 并发情况下只会有一个线程成功(可以理解为乐观锁)
                 */
                if (p.casNext(null, newNode)) {
                    /**
                     * 5.p!=t 代表应该更新tail节点为newNode
                     *  当第一次for循环q!=null 循环找到真正的尾节点的时候cas修改成功的时候才成立
                     *  单线程情况下每次都是间隔一次入队才来更新tail 减少cas修改tail
                     */
                    if (p != t)
                        casTail(t, newNode); //6.cas设置tail为当前新节点 并没有采取重试 有可能失败 失败也没关系 代码3会遍历找到真正尾节点
                    return true;
                }
            } else if (p == q) {
                /**
                 * 7.tail自引用时发生 item就是他自身 重新根据头节点找尾节节点
                 *   自引用即 tail item=next 这个时候head才是真正尾节点
                 *   (t != (t = tail))判断tail是否改变 改变了则取最新tail否则从head开始遍历往下找 找真正节点
                 *   这个判断是防止多线程情况下 有其他线程抢先入队 也可以理解 其他线程已经抢先走了这个分支找到真正尾节点入队并修改了tail
                 *   自引用:并发情况下 又在入队又在出队的情况下会发生  我测试 添加第一个元素就是自引用 后续元素则不是
                 */
                p = (t != (t = tail)) ? t : head;
            else
                /**
                 * 8.当tail并不是最后一个节点时
                 *   对应代码5的延迟修改 以及cas修改失败 或者多线程抢先入队 导致当前线程tail并不是真正尾节点
                 *   (p != t && t != (t = tail)为判断tail是否有其他线程抢先修改 如果有则取最新tail 遍历开始找真正尾节点 否则继续向下寻找
                 * 
                 */
                p = (p != t && t != (t = tail)) ? t : q;
            }
        }

    }

代码1:

         检查代码元素是否为空 如果为空则抛出异常 

代码2:

        创建一个node对象包装值

代码3:

       判断q==null(p=tail,q=p.next) 即判断是否为最后一个节点 这里判断主要出于以下几点考虑

      1.代码5的判断 表示每次都是间隔一次才更新taill 所以tail并不是实时修改的

      2.代码6的cas没有重试 也表示修改taill并不是一定成功的

代码4:

      如果taill是最后一个节点 则cas更新 如果cas更新是吧(表示其他线程抢先更新了 重新执行for循环)

代码5:

       看到这里可能会有疑问(p=t=tail) 为什么要判断p!=t   因为第一次不更新尾节点  所以第二次offer代码3并不会成立走下面else分支重新寻找真正的尾节点 即p不会等于t

代码6:

      这里cas可能会修改失败 但是并没有关系 注意外面for循环 和判断 当不是尾节点 会重新寻找真正的尾节点

代码7:

     p==q(p.next=p)网上资料说poll可能会导致自引用 我jdk8初始化队列 添加第一个元素就回显了自引用(没找到原因)  自引用的时候head才是真正的尾节点

     p = (t != (t = tail)) ? t : head;   这代码 第一个判断是 避免多线程情况下 其他线程入队已经修改了tail的的值 所以这个时候就不是自引用 则取taill遍历找尾节点  否则 从head重新找起

代码8:

     不直接取taill.next为p加入遍历 而是加入了taill是否改变的判断 也是为了防止其他线程修改了tail 如果修改了则取最新tail遍历 否则取p.next遍历查找尾节点

可以看到整个入队都是采用无锁设计 使用cas+循环 保证入队一定会成功,但是增加了for循环遍历次数

poll源码

  public E poll() {
        restartFromHead:
        /**
         * 代码1无限循环
         */
        for (;;) {
            for (ConcurrentLinkedQueue.Node<E> h = head, p = h, q;;) {
                /**
                 * 代码2从head节点开始取
                 */
                E item = p.item;
                /**
                 * 代码3 如果item不为空 表示未出队 同时通过cas将item置为null
                 * 如果cas失败则表示其他线程抢先出队 则重新获取
                 */
                if (item != null && p.casItem(item, null)) {
                    /**
                     *代码4 每次出队并不会马上修改head节点 而是下一次出队时再修改
                     */
                    if (p != h) // hop two nodes at a time
                        updateHead(h, ((q = p.next) != null) ? q : p);
                    return item;
                }
                /**
                 * 代码5 表示队列为空返回null
                 * 如果p.next！=null则继续执行下面逻辑 注意此时q已经被赋值为p.next
                 */
                else if ((q = p.next) == null) {
                    updateHead(h, p);
                    return null;
                }
                /**
                 * 代码6
                 */
                else if (p == q)
                    continue restartFromHead;
                /**
                 * 代码7
                 * 将next节点赋值给p  遍历重新找到head节点
                 * 对应代码3cas失败
                 * 对应代码4不是实时修改head节点
                 * 对应代码5的判断给q复制next节点
                 */
                else
                    p = q;
            }
        }
    }

 size方法

  public int size() {
        // 计数
        int count = 0;
        for (Node<E> p = first(); p != null; p = succ(p)) // 从第一个存活的结点开始往后遍历
            if (p.item != null) // 结点的item域不为null
                // Collection.size() spec says to max out
                if (++count == Integer.MAX_VALUE) // 增加计数，若达到最大值，则跳出循环
                    break;
        // 返回大小
        return count;
    }