JUC基石——Unsafe类

前言

我们经常在JUC包下的ConcurrentHashMap、Atomic开头的原子操作类、AQS以及LockSupport里面看到Unsafe类的身影，这个Unsafe类究竟是干什么的，本文可以带着读者一探究竟。

Java和C++、C语言的一个重要区别，就是Java中我们无法直接操作一块内存区域，而在C++、C中却可以自己申请内存和释放内存。Unsafe类的设计，为我们提供了手动管理内存的能力。

如同它的名字一样，它被认定为不安全的。直接操纵内存，意味着实例化出来的对象不会受到JVM的管理，不会被GC，需要手动进行回收，容易出现内存泄露的问题。因此，官方并不建议我们在自己的应用程序中使用该类。

构造方法

public final class Unsafe {private static final Unsafe theUnsafe;private Unsafe() {}@CallerSensitivepublic static Unsafe getUnsafe() {Class var0 = Reflection.getCallerClass();if (!VM.isSystemDomainLoader(var0.getClassLoader())) {throw new SecurityException("Unsafe");} else {return theUnsafe;}}//其他方法
}

可以看得出来，该类被final修饰，不允许被继承。构造方法是私有的，在外部不可被实例化。（关于final更多的作用，可以移步这篇文章关键词final的作用）

但在内部提供了一个获取单例的getUnsafe()方法，不过该方法做了限制。如果是普通调用的话，它会抛出一个SecurityException异常。只有由系统类加载器(BootStrap classLoader)加载的类才可以调用这个类中的方法。

如果var0由系统类加载器加载的话，那么var0.getClassLoader()会返回null，VM.isSystemDomainLoader(null)则直接返回true，此时便不会抛出SecurityException异常。

当然，也不是无法获取到Unsafe类的实例，我们在文章最后会通过反射来获取。

获取偏移量

    public native long staticFieldOffset(Field var1);public native long objectFieldOffset(Field var1);

staticFieldOffset用于获取某一个静态属性在对象地址中的偏移量
objectFieldOffset用于获取某一个非静态属性在对象实例地址中的偏移量

偏移量这个名词在Unsafe类中十分重要，该类中80%的方法都需要依赖这个偏移量。

分配、释放内存等

    //分配内存public native long allocateMemory(long var1);//扩展或重新分配内存public native long reallocateMemory(long var1, long var3);//内存初始化public native void setMemory(Object var1, long var2, long var4, byte var6);//内存复制public native void copyMemory(Object var1, long var2, Object var4, long var5, long var7);//释放内存public native void freeMemory(long var1);//创建对象实例并返回该实例public native Object allocateInstance(Class<?> var1) throws InstantiationException;

其中allocateMemory()、reallocateMemory()、freeMemory()分别用于分配内存，扩展或重新分配内存和释放内存，与C语言中 malloc()、realloc()、free()对应。

allocateInstance()方法会通过Class对象创建一个类的实例，且不需要调用其构造函数、初始化代码、JVM安全检查等等。

普通读写

    public native int getInt(long var1);public native void putInt(long var1, int var3);

getInt() 在指定内存地址var1处读取一个int
putInt() 在指定内存地址var1处写入一个新int类型的数据var3

普通的读写，无法保证有序性与可见性。关于可见性，可以先移步到我的另外一篇文章多线程之内存可见性

volatile读写

    public native int getIntVolatile(Object var1, long var2);public native void putIntVolatile(Object var1, long var2, int var4);

getIntVolatile 在对象var1的指定偏移处var2读取一个int
putIntVolatie 在对象var1的指定偏移处var2写入一个int类型的数据var4

volatie能够保证有序性以及可见性，volatie保证有序性的一个实例，可以参考我的另外一篇文章浅说Synchronized中使用synchronized与volatie实现单例模式中双重检验锁的部分。

CAS操作

    public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

以compareAndSwapInt为例，在对象var1指定偏移量var2处读取一个int值real，如果var4=real，则用var5更新这个real，并返回true，否则返回false。

CAS用于实现乐观锁，每次更新时，都假设不会有其他线程并发修改，而只是在修改的时候判断该值是否被修改过。如果符合预期的值，则直接更新它，否则进入忙循环中，一直判断是否符合期望。在循环次数少便可以直接更新值的情况下，CAS机制比悲观锁拥有更好的性能。当然，如果循环次数过多，也是会白白浪费CPU资源。

synchronized就是一中悲观锁的实现，关于synchronized原理，可以移步我的另外一篇文章Synchronized的优化

关于CAS机制的详细介绍，我会另开篇幅。

线程调度

    public native void park(boolean var1, long var2);public native void unpark(Object var1);

park() 用于阻塞当前线程，如果var1=true，则var2的单位为毫秒，否则为纳秒。
unpark() 用于恢复一个之前被park的线程var1

LockSupport里面的park()与unpark()方法内部正是通过以上两个本地方法来实现的。

内存屏障

    public native void loadFence();public native void storeFence();public native void fullFence();

loadFence 保证在这个屏障之前，所有的读操作全部完成。这里的load对应于从局部变量表中读取某个位置上的元素到栈顶
storeFence 保证在这个屏障之前，所有的写操作全部完成。这里的store对应于从栈顶出栈某个元素保存到局部变量表的某个位置上
fullFence 保证在这个屏障之前，所有的读写操作全部完成，相当于load+store

反射获取Unsafe实例

package com.yang.testUnsafe;import sun.misc.Unsafe;import java.lang.reflect.Field;public class Main {static class Student {private String name;private int age;public Student() {System.out.println("通过构造方法");}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}}public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, InstantiationException {//1.获取Unsafe类的实例//但无法通过Unsafe.getUnsafe()，由于Main类不是系统类加载器加载，因此会抛出SecurityException异常//Unsafe unsafe = Unsafe.getUnsafe();Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");theUnsafe.setAccessible(true);Unsafe unsafe = (Unsafe) theUnsafe.get(null);//2.为Student对象分配内存//该方法不需要调用构造方法Student student = (Student) unsafe.allocateInstance(Student.class);//3.获取student实例中age属性的偏移量Field age = student.getClass().getDeclaredField("age");long ageOffset = unsafe.objectFieldOffset(age);//4.利用CAS操作，当age=0时，将age变为1boolean casResult = unsafe.compareAndSwapInt(student, ageOffset, 0, 1);System.out.println(casResult);//输出trueSystem.out.println(student.getAge());//输出1}
}

总结

使用Unsafe类直接操纵内存，意味着速度更快，效率更高，但也更加危险。之前盛传Unsafe类将在Java9中移除，一时间风波四起，具体的文章可以参考这篇Java 9中将移除 Sun.misc.Unsafe(译)。

但其实Java9出现之后，只是对其进行了改进和优化，不过依然是不推荐开发者使用Unsafe类。