关于volatile修饰的成员变量的性能问题-CFANZ编程社区

前言:

今天偶然看到ConcurrentLinkedQueue的内部类ConcurrentLinkedQueue.Node, 发现其两个成员变量item, next都是由volatile进行修饰, 而且赋值都是用sun的misc包下UNSAFE类进行的。我非常好奇，为啥会有这种操作？(我个人估计是性能考虑), 下面就进行了实验。

UNSAFE类意义:

sun.misc.Unsafe是JDK内部用的工具类。它通过暴露一些Java意义上说“不安全”的功能给Java层代码，来让JDK能够更多的使用Java代码来实现一些原本是平台相关的、需要使用native语言（例如C或C++）才可以实现的功能。该类不应该在JDK核心类库之外使用。

JVM的实现可以自由选择如何实现Java对象的“布局”，也就是在内存里Java对象的各个部分放在哪里，包括对象的实例字段和一些元数据之类。sun.misc.Unsafe里关于对象字段访问的方法把对象布局抽象出来，它提供了objectFieldOffset()方法用于获取某个字段相对Java对象的“起始地址”的偏移量，也提供了getInt、getLong、getObject之类的方法可以使用前面获取的偏移量来访问某个Java对象的某个字段。

Oracle/Sun HotSpot VM所使用的Unsafe对象可以参考这篇博客：http://mishadoff.com/blog/java-magic-part-4-sun-dot-misc-dot-unsafe/

实验:

1. unsafe.putObject(this, itemOffset, item)
   直接在对象的itemOffset位置设置item的引用(越过访问权限)

2. unsafe.putOrderedObject(this, nextOffset, val)
   在对象的itemOffset位置设置item的引用, 只不过这个方法的可见性比直接用 putObject 方法低一点, 其他的线程要过一段时间才可见

putOrderedObject 使用 store-store barrier屏障, 而 putObject还会使用 store-load barrier 屏障(对于Java中的指令屏障不了解的直接可以参考 Java并发编程艺术)

我参照ConcurrentLinkedQueue的内部类ConcurrentLinkedQueue.Node类写了个类似的类,如下:

class UnsafeNode<T> {
    volatile T item;
    volatile UnsafeNode<T> next;
    static final sun.misc.Unsafe UNSAFE;
    static final long itemOffset;
    static final long nextOffset;

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

    UnsafeNode(T item) {
        UNSAFE.putObject(this, itemOffset, item);
    }

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

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

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

然后写了个Test方法进行测试, 先测试用UNSAFE.putObject(...)方法对volatile成员变量进行赋值。我高高兴兴地Run Test Case，结果立马报错......

        // Unsafe赋值性能测试
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(sdf.format(new Date()));

        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            UnsafeNode<Integer> node = new UnsafeNode<>(i);
        }

        System.out.println(sdf.format(new Date()));

好吧认为我不安全......正如Unsafe的类注释中写的:

我只能用反射去搞了:

        Field theUnsafeInstance = Unsafe.class.getDeclaredField("theUnsafe");
        theUnsafeInstance.setAccessible(true);
        sun.misc.Unsafe UNSAFE = (Unsafe) theUnsafeInstance.get(Unsafe.class);

测试Node，UnfaseNode代码改成如下:

class UnsafeNode<T> {
    volatile T item;
    volatile UnsafeNode<T> next;
    static final sun.misc.Unsafe UNSAFE;
    static final long itemOffset;
    static final long nextOffset;

    static {
        try {
            //获取 Unsafe 内部的私有的实例化单例对象
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            //无视权限
            field.setAccessible(true);
            UNSAFE = (Unsafe) field.get(null);
            Class<?> klass = UnsafeNode.class;
            itemOffset = UNSAFE.objectFieldOffset
                    (klass.getDeclaredField("item"));
            nextOffset = UNSAFE.objectFieldOffset
                    (klass.getDeclaredField("next"));
        } catch (Exception e) {
            throw new Error(e);
        }
    }

    UnsafeNode(T item) {
        UNSAFE.putObject(this, itemOffset, item);
    }

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

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

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

用Test Case再次跑: 哈哈成功了，用了不到1s完成。?

我再用普通赋值方法去完成volatile变量的赋值，新的数据结构Node类如下:

class NormalNode<T> {

    volatile T item;
    volatile NormalNode<T> next;

    NormalNode(T it) {
        item = it;
        next = null;
    }

    //忽略其他...
}

然后改下Test Case测试方法:

         // 普通volitile赋值性能测试
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(sdf.format(new Date()));

        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            NormalNode<Integer> node = new NormalNode<>(i);
        }

        System.out.println(sdf.format(new Date()));

结果相同功能竟然用了花了3s！性能相差3倍以上!