Unsafe类的介绍和使用

时间 2019-11-17

标签 unsafe 介绍使用繁體版

原文原文链接

近期在看JDK8的ConcurrentHashMap源码时，发现里面大量用到了Unsafe类的API，这里来深刻研究一下。java

0 简介

Java是一个安全的面向对象的编程语言。这里的安全指的是什么呢？不妨从什么是不安全的角度来看看。linux

啥是不安全呢？这里以C语言为例，在C语言中：c++

当编写了开辟内存的代码以后，须要想着手动去回收这块内存，不然会形成内存泄漏；
指针的操做提供了不少的便利，但若是出现了例如计算指针指向地址错误的问题，就会产生不少意想不到的结果；

其余的不安全的状况这里再也不一一列举。在Java中，很好的解决了C语言中诸多的不安全问题。例如用GC解决了内存回收的问题，而Java中自己没有指针的概念，只是提供了引用类型，而引用类型是没法直接修改其引用的内存地址的，因此指针误操做的问题也获得了有效的解决。编程

那么，在Java中有没有突破这些限制的方法呢？答案是确定的，他就是今天要聊的sum.misc.Unsafe类。安全

使用Unsafe的API，你能够：微信

开辟内存：allocateMemory
扩充内存：reallocateMemory
释放内存：freeMemory
在指定的内存块中设置值：setMemory
未经安全检查的加载Class：defineClass
原子性的更新实例对象指定偏移内存地址的值：compareAndSwapObject
获取系统的负载状况：getLoadAverage，等同于linux中的uptime
不调用构造函数来建立一个类的实例：allocateInstance

本文会介绍几个API的使用方式，但主要关注可用于处理多线程并发问题的几个API：多线程

compareAndSwapInt
getAndAddInt
getIntVolatile

1 在OpenJDK中查看Unsafe源码

想要了解Unsafe，最直接的一个方式就是看源码啦。并发

可是从Oracle官方下载的JDK中，Unsafe类是没有注释的。而OpenJDK中是有的，咱们能够从OpenJDK源码入手。app

下面介绍一下如何经过OpenJDK查看Unsafe源码（一样适用与查看其它类的源码以及查看native实现）。dom

1.1 下载OpenJDK8

从下面连接下载 OpenJDK8

点下面这里下载便可

下载后是zip包，解压到一个地方就好。

1.2 下载NetBeans

由于咱们接下来要同时看C++和Java的源码，NetBeans是同时支持这两种语言的，因此这里经过NetBeans来看OpenJDK的源码。

下载地址为：

NetBeans下载

http://137.254.56.27/download/trunk/nightly/latest

注意要下载这个ALL版本的，只有这个才能同时支持Java和C++。

1.3 导入OpenJDK源码

文件 -> 新建项目
按下面这样选择，而后下一步
选择刚才解压出来的openjdk根目录
点击“完成”

Unsafe的源码在jdk/src/share/classes/sun/misc/Unsafe.java

2 Unsafe的获取

经过源码发现，Unsafe在JVM中是一个单例对象，咱们不能直接去new它。

private Unsafe() {}

private static final Unsafe theUnsafe = new Unsafe();
复制代码

继续往下看，而后能够发现有这样一个方法

/** * Provides the caller with the capability of performing unsafe * operations. * * <p> The returned <code>Unsafe</code> object should be carefully guarded * by the caller, since it can be used to read and write data at arbitrary * memory addresses. It must never be passed to untrusted code. * * <p> Most methods in this class are very low-level, and correspond to a * small number of hardware instructions (on typical machines). Compilers * are encouraged to optimize these methods accordingly. * * <p> Here is a suggested idiom for using unsafe operations: * * <blockquote><pre> * class MyTrustedClass { * private static final Unsafe unsafe = Unsafe.getUnsafe(); * ... * private long myCountAddress = ...; * public int getCount() { return unsafe.getByte(myCountAddress); } * } * </pre></blockquote> * * (It may assist compilers to make the local variable be * <code>final</code>.) * * @exception SecurityException if a security manager exists and its * <code>checkPropertiesAccess</code> method doesn't allow * access to the system properties. */
@CallerSensitive
public static Unsafe getUnsafe() {
    Class<?> caller = Reflection.getCallerClass();
    if (!VM.isSystemDomainLoader(caller.getClassLoader()))
        throw new SecurityException("Unsafe");
    return theUnsafe;
}
复制代码

看似咱们能够经过Unsafe.getUnsafe()来获取Unsafe的实例。

其实否则，这个方法在return以前作了一个校验，他会经过VM.isSystemDomainLoader方法校验调用者的ClassLoader，此方法的实现以下

/** * Returns true if the given class loader is in the system domain * in which all permissions are granted. */
public static boolean isSystemDomainLoader(ClassLoader loader) {
    return loader == null;
}
复制代码

若是调用者的ClassLoader==null，在getUnsafe方法中才能够成功返回实例，不然会抛出SecurityException("Unsafe")异常。

啥时候是null呢？能够想到只有由启动类加载器（BootstrapClassLoader）加载的class才是null。

PS：关于类加载器能够参考笔者的另外一篇文章: 深刻分析Java类加载器原理

因此在咱们本身的代码中是不能直接经过这个方法获取Unsafe实例的。

还有啥别的办法么？有的！反射大法好！

在源码中能够发现，它是用theUnsafe字段来引用unsafe实例的，那咱们能够尝试经过反射获取theUnsafe字段，进而获取Unsafe实例。代码以下：

import sun.misc.Unsafe;

import java.lang.reflect.Field;

public class UnsafeTest1 {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        Class klass = Unsafe.class;
        Field field = klass.getDeclaredField("theUnsafe");
        field.setAccessible(true);
        Unsafe unsafe = (Unsafe) field.get(null);
        System.out.println(unsafe.toString());
    }
}
复制代码

运行此代码，没有报错，大功告成。

3 Unsafe几个API的使用

3.1 经过内存偏移量原子性的更新成员变量的值

import sun.misc.Unsafe;

import java.lang.reflect.Field;

/** * Description: * * @author zhiminxu * @package com.lordx.sprintbootdemo * @create_time 2019-03-22 */
public class UnsafeTest {

    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, InterruptedException {
        Test test = new Test();
        test.test();
    }
}

class Test {

    private int count = 0;

    public void test() throws NoSuchFieldException, IllegalAccessException {
        // 获取unsafe实例
        Class klass = Unsafe.class;
        Field field = klass.getDeclaredField("theUnsafe");
        field.setAccessible(true);
        Unsafe unsafe = (Unsafe) field.get(null);

        // 获取count域的Field
        Class unsafeTestClass = Test.class;
        Field fieldCount = unsafeTestClass.getDeclaredField("count");
        fieldCount.setAccessible(true);

        // 计算count的内存偏移量
        long countOffset = (int) unsafe.objectFieldOffset(fieldCount);
        System.out.println(countOffset);

        // 原子性的更新指定偏移量的值（将count的值修改成3）
        unsafe.compareAndSwapInt(this, countOffset, count, 3);

        // 获取指定偏移量的int值
        System.out.println(unsafe.getInt(this, countOffset));
    }
}
复制代码

3.2 用Unsafe模拟synchronized

用到了Unsafe中的monitorEnter和monitorExit方法，但monitorEnter后必定要记着monitorExit。

import sun.misc.Unsafe;

import java.lang.reflect.Field;

/** * Description: * * @author zhiminxu * @package com.lordx.sprintbootdemo * @create_time 2019-03-22 */
public class UnsafeTest {

    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, InterruptedException {
        final Test test = new Test();
        // 模拟两个线程并发给Test.count递增的场景
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000000; i++) {
                    test.addCount();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000000; i++) {
                    test.addCount();
                }
            }
        }).start();
        Thread.sleep(5000);
        System.out.println(test.getCount());
    }
}

class Test {

    private int count = 0;

    public int getCount() {
        return this.count;
    }

    private Unsafe unsafe;
    public Test() {
        try {
            Class klass = Unsafe.class;
            Field field = klass.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            unsafe = (Unsafe) field.get(null);
        }catch (Exception e) {
            e.printStackTrace();
        }
    }

    private Object lock = new Object();

    public void addCount() {
        // 给lock对象设置锁
        unsafe.monitorEnter(lock);
        count++;
        // 给lock对象解锁
        unsafe.monitorExit(lock);
    }


}
复制代码

4 Unsafe中几个线程安全API的实现原理

4.1 compareAndSwapInt

此方法在Unsafe中的源码为

/** * Atomically update Java variable to <tt>x</tt> if it is currently * holding <tt>expected</tt>. * 若是对象o指定offset所持有的值是expected，那么将它原子性的改成值x。 * @return <tt>true</tt> if successful */
public final native boolean compareAndSwapInt(Object o, long offset, int expected, int x);
复制代码

在OpenJDK中能够看到这个方法的native实现，在unsafe.cpp中。

UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))
  UnsafeWrapper("Unsafe_CompareAndSwapInt");
  // #1
  oop p = JNIHandles::resolve(obj);
  // #2
  jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);
  // #3
  return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
UNSAFE_END
复制代码

代码#1将目标对象转换为oop，oop是本地实现中oopDesc类的实现，其定义在oop.hpp中。oopDesc是全部class的顶层baseClass，它描述了Java object的格式，使Java object中的field能够被C++访问。

代码#2负责获取oop中指定offset的内存地址，指针变量addr记录的就是这个地址中存储的int值。

代码#3调用Atomic::cmpxchg来原子性的完成值得替换。

4.2 getAndAddInt

此方法的源码以下

/** * Atomically adds the given value to the current value of a field * or array element within the given object <code>o</code> * at the given <code>offset</code>. * * @param o object/array to update the field/element in * @param offset field/element offset * @param delta the value to add * @return the previous value * @since 1.8 */
public final int getAndAddInt(Object o, long offset, int delta) {
    int v;
    do {
        v = getIntVolatile(o, offset);
    } while (!compareAndSwapInt(o, offset, v, v + delta));
    return v;
}
复制代码

用于原子性的将值delta加到对象o的offset上。

getIntVolatile方法用于获取对象o指定偏移量的int值，此操做具备volatile内存语义，也就是说，即便对象o指定offset的变量不是volatile的，次操做也会使用volatile语义，会强制从主存获取值。

而后经过compareAndSwapInt来替换值，直到替换成功后，退出循环。

欢迎关注个人微信公众号