关于volatile修饰的成员变量的性能问题

作者 : 开心源码 本文共3925个字,预计阅读时间需要10分钟 发布时间: 2022-05-13 共260人阅读

前言:

  今天偶然看到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,结果立马报错……

have_no_choice.png

        // 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_Fail.png

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

Although the class and all methods are public, use of this class is limited because only trusted code can obtain instances of it.

  我只能用反射去搞了:

        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完成。?

Unsafe_Success.png

  我再用普通赋值方法去完成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倍以上!

No_Unsafe_Success.png

结论:

  一个普通的volatile成员变量赋值,JDK都考虑地很周到,推荐大家有空多翻翻JDK各个模块,能学好很多,别嘲笑我才发现这个性能点……?。
下次具体和大家说说Magic Happens的源头。 sun.misc.Unsafe类,做详解Unsafe文章。

说明
1. 本站所有资源来源于用户上传和网络,如有侵权请邮件联系站长!
2. 分享目的仅供大家学习和交流,您必须在下载后24小时内删除!
3. 不得使用于非法商业用途,不得违反国家法律。否则后果自负!
4. 本站提供的源码、模板、插件等等其他资源,都不包含技术服务请大家谅解!
5. 如有链接无法下载、失效或广告,请联系管理员处理!
6. 本站资源售价只是摆设,本站源码仅提供给会员学习使用!
7. 如遇到加密压缩包,请使用360解压,如遇到无法解压的请联系管理员
开心源码网 » 关于volatile修饰的成员变量的性能问题

发表回复