ConcurrentLinkedQueue的原理以及CAS机制在其中的应用

ConcurrentLinkedQueue是一个线程安全队列,区别于阻塞算法的锁机制,它使用了基于CAS机制的非阻塞算法。
基本概念介绍:
队列:通常(但并非一定)以 FIFO(先进先出)的方式排序各个元素。
接口Queue

接口quque中的方法可以分为三类
添加队列尾元素  
boolean add(E e)与boolean offer(E e)
add结果只能为返回true(成功插入)或抛出异常(不成功),根据异常类型(IllegalStateException)才能看出是否由于对列容量限制
offer结果返回true(成功插入)或返回false(容量限制)或抛出异常

获取队列头但不移除  
E element() 与 E peek()
区别在于当队列为空时 elemnet()方法抛出异常
peek方法返回null

获取对列头并移除
remove() 与 poll()
区别在于队列为空时 remove()方法抛出异常
poll方法返回null

之前文章说明过CAS机制的依据(硬件层面的是实现):http://blog.csdn.net/do_finsh/article/details/78773573
以及大体java.util.concurrent包下的类实现的共同点:

  1. .声明共享变量为volatile;(没有原子性,有可见性)
  2. 使用CAS的原子条件更新来实现线程之间的同步;
  3. 配合以volatile的读/写和CAS所具有的volatile读和写的内存语义来实现线程之间的通信。

现在具体说明一下ConcurrentLinkedQueue中的应用

首先出现了一个私有静态类Node
这个Node类中出现了UNSAFE类,节点类Node< E> 通过UNSAFE类的方法,进行CAS操作。大致了解一下
UNSAFE类的方法

    // 获取f在堆内存的偏移地址
    public native long objectFieldOffset(Field f);

    // 获取静态f在堆内存的偏移地址
    public native long staticFieldOffset(Field f);

    // 原子的更改offset地址的变量。如果变量的值为expected,并成功替换为x 返回true  CAS操作
    public final native boolean compareAndSwapObject(Object o, long offset, Object expected,Object x);

    // 将offset地址的值替换为x,并且通知其他线程。因为有Volatile,与putObject类似
    public native void putObjectVolatile(Object o, long offset, Object x);

    // 获取地址为offset 的值
    public native Object getObjectVolatile(Object o, long offset)

   /**
     * Version of {@link #putObjectVolatile(Object, long, Object)}
     * that does not guarantee immediate visibility of the store to
     * other threads. This method is generally only useful if the
     * underlying field is a Java volatile (or if an array cell, one
     * that is otherwise only accessed using volatile accesses).
     */
public native void putOrderedObject(Object o, long offset, Object x);

节点类Node

private static class Node<E> {
        volatile E item; // volatile声明
        volatile Node<E> next; // volatile声明
        // 构造方法  在地址itemOffset处, 值替换为item
        Node(E item) {
            UNSAFE.putObject(this, itemOffset, item);
        }
        // CAS操作:比较并交换,原子的更改itemOffset地址的变量。如果变量的值为cmp,并成功替换为val 返回true  
        boolean casItem(E cmp, E val) {
            return UNSAFE.compareAndSwapObject(this, itemOffset, cmp, val);
        }
       // 将nextOffset地址的值替换为x
        void lazySetNext(Node<E> val) {
            UNSAFE.putOrderedObject(this, nextOffset, val);
        }
        // CAS操作:比较并交换,原子的更改nextOffset地址的变量。如果变量的值为cmp,并成功替换为val 返回true
        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;
        /**
          * 静态代码块,获取itemOffset和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的常用方法offer(E e);

public boolean offer(E e) {
        checkNotNull(e);
        //创建一个入队节点
        final Node<E> newNode = new Node<E>(e);
        // 死循环,直到return ture 
        // 创建一个指向tail节点的引用t
        // p用来表示尾结点
        for (Node<E> t = tail, p = t;;) { 
            // 获取p的下一节点
            Node<E> q = p.next;
            // 如果q为空,说明p是尾节点
            if (q == null) {
                // p是尾节点,把e放入p节点之后,CAS操作(原子性操作),成功,跳出循环
                if (p.casNext(null, newNode)) {
                    if (p != t) 
                    // 如果tail不是尾节点则将入队节点设置为tail。如果失败了,那么说明有其他线程已经把tail移动过
                        casTail(t, newNode); 
                    return true;
                }
            }
            // 如果p节点等于p的next节点,则说明p节点和q节点都为空,表示队列刚初始化,所以返回 
            else if (p == q)
                p = (t != (t = tail)) ? t : head;
            else
                //p有next节点,表示p的next节点是尾节点,则需要重新更新p后将它指向next节点
                //此步判断非原子性操作t != (t = tail)
                p = (p != t && t != (t = tail)) ? t : q;
        }
    }
发布了14 篇原创文章 · 获赞 7 · 访问量 3万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览