一个名为不安全的类Unsafe

最近为了更加深入了解NIO的实现原理，学习NIO的源码时，遇到了一个问题。即在WindowsSelectorImpl中的

pollWrapper属性，当我点进去查看它的PollArrayWrapper类型时，发现它和AllocatedNativeObject类型有关，而AllocatedNativeObject继承了NativeObject类，随着又发现了NativeObject是基于一个Unsafe类实现的。不安全的类？？？？

Unsafe

Unsafe，顾名思义，它真是一个不安全的类，那它为什么是不安全的呢？这就要从Unsafe类的功能说起。

学过C#的就可以知道，C#和Java的一个重要区别就是：C#可以直接操作一块内存区域，如自己申请内存和释放，而在Java中这是做不到的。而Unsafe类就可以让我们在Java中像C#一样去直接操作一块内存区域，正因为Unsafe类可以直接操作内存，意味着其速度更快，在高并发的条件之下能够很好地提高效率，所以java中很多并发框架，如Netty，都使用了Unsafe类。

虽然，Unsafe可以提高运行速度，但是因为Java本身是不支持自己直接操作内存的，这就意味着Unsafe类所做的操作不受jvm管理的，所以不会被GC(垃圾回收)，需要我们手动GC，稍有不慎就会出现内存泄漏问题。且Unsafe的不少方法中必须提供原始地址(内存地址)和被替换对象的地址，偏移量要自己计算，一旦出现问题就是JVM崩溃级别的异常，会导致整个JVM实例崩溃。这就是为什么Unsafe被称为不安全的原因。Unsafe可以让你全力踩油门，提高自己的速度，但是它会让你的方向盘更难握稳，一不小心就可能导致车毁人亡。

源码查看

初始化

因为Unsafe的构造方法是private类型的，所以无法通过new方式实例化获取，只能通过它的getUnsafe()方法获取。又因为Unsafe是直接操作内存的，为了安全起见，Java的开发人员为Unsafe的获取设置了限制，所以想要获取它只能通过Java的反射机制来获取。

@CallerSensitive
public static Unsafe getUnsafe() {
    //通过getCallerClass方法获取Unsafe类
    Class var0 = Reflection.getCallerClass();
    //如过该var0类不是启动类加载器(Bootstrap)，则抛出异常
    //正因为该判断，所以Unsafe只能通过反射获取
    if (!VM.isSystemDomainLoader(var0.getClassLoader())) {
        throw new SecurityException("Unsafe");
    } else {
        return theUnsafe;
    }
}

• Reflection.getCallerClass()：可以返回调用类或Reflection类，或者层层上传

• VM.isSystemDomainLoader(ClassLoader var0)：判断该类加载器是否是启动类加载器(Bootstrap)。

• @CallerSensitive：为了防止黑客通过双重反射来提升权限，所以所有跟反射相关的接口方法都标注上CallerSensitive

所以使用下面的方式是获取不了Unsafe类的：

//使用这样的方式获取会抛出异常，因为是通过系统类加载器加载(AppClassLoader)
public class Test {
    public static void main(String[] args) {
        Unsafe unsafe = Unsafe.getUnsafe();
    }
}

那怎么才用使用启动类加载Unsafe类并获取它呢？在Unsafe类的最下面的static代码块中有这样一段代码：

private static final Unsafe theUnsafe;
//.....
static {
    registerNatives();
    Reflection.registerMethodsToFilter(Unsafe.class, new String[]{"getUnsafe"});
    theUnsafe = new Unsafe();
    //......
}

学过反射机制看过以上代码就可以知道我们可以通过getDeclaredField()返回获取Un safe类的theUnsafe属性，然后通过该属性获取Unsafe类的实例，因为在Unsafe类里的theUnsafe属性已经被new实例化了。

public class Test {
    public static void main(String[] args) throws Exception {
        //通过getDeclaredField方法获取Unsafe类中名为theUnsafe的属性
        //注意，该属性是private类型的，所以不能用getField获取，只能用getDeclaredField
        Field field = Unsafe.class.getDeclaredField("theUnsafe");
        //将该属性设为可访问
        field.setAccessible(true);
        //实例该属性并转为Unsafe类型
        //因为theUnsafe属性是Unsafe类所在的包的启动类加载的，所以可以成功获得
        Unsafe unsafe = (Unsafe)field.get(null);
    }
}

获取偏移量方法

偏移量

在实际模式中，内存是被分成段的，如果想要获取内存中的某个储存单元，需知道储存单元的所在段地址(段头)和偏移量，即使你知道该储存单元的实际地址。而偏移量就是实际地址与所在段地址(段头)的距离，偏移量=实际地址-所在段地址(段头)。

举个例子，假设有个书架，我需要找由左到右、由上到下数的第1024本书，那我只能一本本的数，直到数到第1024本，但如果我知道书架的第4层的第一本书是第1000本书，那我只用从第1000本书开始数，数到1024，只需数1024-1000=24本。在这里，书架是内存，要找的书就是储存单元，书架的第4层就是内存段，第4层的第一本书即书架的第1000本书就是段地址(段头)，第1024本书就是实际地址，而偏移量的就是第1000本书到第1024本书的距离24.

public native long objectFieldOffset(Field var1);

获取非静态变量var1的偏移量。

public native long staticFieldOffset(Field var1);

获取静态变量var1的偏移量。

public native Object staticFieldBase(Field var1);

获取静态变量var1的实际地址，配合staticFieldOffset方法使用，可求出变量所在的段地址

public native int arrayBaseOffset(Class<?> var1);

获取数组var1中的第一个元素的偏移量，即数组的基础地址。

在内存中，数组的存储是以一定的偏移量增量连续储存的，如数组的第一个元素的实际地址为24，偏移量为4，而数组的偏移量增量为1，那数组的第二个元素的实际地址就是25，偏移量为5.

public native int arrayIndexScale(Class<?> var1);

获取数组var1的偏移量增量。结合arrayBaseOffset(Class<?> var1)方法就可以求出数组中各个元素的地址。

操作属性方法

public native Object getObject(Object var1, long var2);

获取var1对象中偏移量为var2的Object对象，该方法可以无视修饰符限制。相同方法有getInt、getLong、getBoolean等。

public native void putObject(Object var1, long var2, Object var4);

将var1对象中偏移量为var2的Object对象的值设为var4，该方法可以无视修饰符限制。相同的方法有putInt、putLong、putBoolean等。

public native Object getObjectVolatile(Object var1, long var2);

功能与getObject(Object var1, long var2)一样，但该方法可以保证读写的可见性和有序性，可以无视修饰符限制。相同的方法有getIntVolatile、getLongVolatile、getBooleanVolatile等。

public native void putObjectVolatile(Object var1, long var2, Object var4);

功能与putObject(Object var1, long var2, Object var4)一样，但该方法可以保证读写的可见性和有序性，可以无视修饰符限制。相同的方法有putIntVolatile、putLongVolatile、putBooleanVolatile等。

public native void putOrderedObject(Object var1, long var2, Object var4);

功能与putObject(Object var1, long var2, Object var4)一样，但该方法可以保证读写的有序性(不保证可见性)，可以无视修饰符限制。相同的方法有putOrderedInt、putOrderedLong等。

操作内存方法

public native int addressSize();

获取本地指针大小，单位为byte，通常值为4或8。

public native int pageSize();

获取本地内存的页数，该返回值会是2的幂次方。

public native long allocateMemory(long var1);

开辟一块新的内存块，大小为var1(单位为byte)，返回新开辟的内存块地址。

public native long reallocateMemory(long var1, long var3);

将内存地址为var3的内存块大小调整为var1(单位为byte)，返回调整后新的内存块地址。

public native void setMemory(long var2, long var4, byte var6);

从实际地址var2开始将后面的字节都修改为var6，修改大小为var4(通常为0)。

public native void copyMemory(Object var1, long var2, Object var4, long var5, long var7);

从对象var1中偏移量为var2的地址开始复制，复制到var4中偏移量为var5的地址，复制大小为var7。

当var1为空时，var2就不是偏移量而是实际地址，当var4为空时，var5就不是偏移量而是实际地址。

public native void freeMemory(long var1);

释放实际地址为var1的内存。

线程挂起和恢复方法

public native void unpark(Object var1);

将被挂起的线程var1恢复，由于其不安全性，需保证线程var1是存活的。

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

当var2等于0时，线程会一直挂起，知道调用unpark方法才能恢复。

当var2大于0时，如果var1为false，这时var2为增量时间，即线程在被挂起var2秒后会自动恢复，如果var1为true，这时var2为绝对时间，即线程被挂起后，得到具体的时间var2后才自动恢复。

CAS方法

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

CAS机制相关操作，对对象var1里偏移量为var2的变量进行CAS修改，var4为期待值，var5为修改值，返回修改结果。相同方法有compareAndSwapInt、compareAndSwapLong。

类加载方法

public native boolean shouldBeInitialized(Class<?> var1);

判断var1类是否被初始。

public native void ensureClassInitialized(Class<?> var1);

确保var1类已经被初始化。

public native Class<?> defineClass(String var1, byte[] var2, int var3, int var4, ClassLoader var5, ProtectionDomain var6);

定义一个类，用于动态的创建类。var1为类名，var2为类的文件数据字节数组，var3为var2的输入起点，var4为输入长度，var5为加载该类的加载器，var6为保护领域。返回创建后的类。

public native Class<?> defineAnonymousClass(Class<?> var1, byte[] var2, Object[] var3);

用于动态的创建匿名内部类。var1为需创建匿名内部类的类，var2为匿名内部类的文件数据字节数组，var3为修补对象。返回创建后的匿名内部类。

public native Object allocateInstance(Class<?> var1) throws InstantiationException;

创建var1类的实例，但是不会调用var1类的构造方法，如果var1类还没有初始化，则进行初始化。返回创建实例对象。

内存屏障方法

public native void loadFence();

所有读操作必须在loadFence方法执行前执行完毕。

public native void storeFence();

所有写操作必须在storeFence方法执行前执行完毕。

public native void fullFence();

所有读写操作必须在fullFence方法执行前执行完毕。

疑惑

看到这里可能有人会有一个疑惑，为什么这些方法都没有具体的功能实现代码呢？

在文章开头时就说过，Java不支持直接操作内存，那怎么可能用Java来具体实现功能呢。你可以发现Unsafe类内的大多方法都有native修饰符，native接口可以让你调用本地的代码文件（包括其他语言，如c语言），既然Java实现不了，那就让能实现的人来做，所以Unsafe的底层实现语言其实是C语言，这也是为什么Unsafe类内会有偏移量和指针这些Java中没有的概念了。

(以上为本人自己对Unsafe类的理解，如果有错误，欢迎各位前辈指出)