1. UnSafe 简介

Unsafe是 Java 整个并发包底层实现的核心，它具有像 C++ 的指针一样直接操作内存的能力，而这也就意味着其越过了 JVM 的限制。Unsafe 的特性可归结如下，它虽然在一定程度上提升了效率，但是也带来了指针的不安全性

Unsafe 不受 JVM 管理，也就无法被自动 GC，需要手动 GC，容易出现内存泄漏

Unsafe 的大部分方法中必须提供原始地址(内存地址)和被替换对象的地址，偏移量需自行计算，一旦出现问题必然是 JVM 崩溃级别的异常，会导致整个应用程序直接 crash

直接操作内存，也意味着其速度更快，在高并发的条件之下能够很好地提高效率

2. UnSafe 功能与使用示例

Unsafe 类的构造函数是私有的，而对外提供的静态方法Unsafe#getUnsafe() 又对调用者的 ClassLoader 有限制，如果这个方法的调用者不是由 Boot ClassLoader 加载的，则会报错

public static Unsafe getUnsafe() {
    
    
        Class var0 = Reflection.getCallerClass();
        if (!VM.isSystemDomainLoader(var0.getClassLoader())) {
    
    
            throw new SecurityException("Unsafe");
        } else {
    
    
            return theUnsafe;
        }
    }

因为 Java 源码中由开发者自定义的类都是由 Appliaction ClassLoader 加载的，所以正常情况下我们无法直接使用Unsafe ，如果需要使用它，则需要利用反射

public static Unsafe getUnsafe() {
    
    
        Unsafe unsafe = null;
        try {
    
    
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            unsafe = (Unsafe) field.get(null);
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
        return unsafe;
    }

2.1 操作对象属性

方法	功能
`public native Object getObject(Object o, long offset)`	获取一个Java 对象中偏移地址为 offset 的属性的值，此方法可以突破修饰符的限制，类似的方法有 `getInt()、getDouble()`等，同理还有 putObject() 方法
`public native Object getObjectVolatile(Object o, long offset)`	强制从主存中获取目标对象指定偏移量的属性值，类似的方法有`getIntVolatile()、getDoubleVolatile()`等，同理还有`putObjectVolatile()`
`public native void putOrderedObject(Object o, long offset, Object x)`	设置目标对象中偏移地址 offset 对应的对象类型属性的值为指定值。这是一个有序或者有延迟的 `putObjectVolatile()`方法，并且不保证值的改变被其他线程立即看到。只有在属性被`volatile`修饰并且期望被修改的时候使用才会生效，类似的方法有 `putOrderedInt() 和 putOrderedLong()`
`public native long objectFieldOffset(Field f)`	返回给定的非静态属性在它的类的存储分配中的位置(偏移地址)，然后可根据偏移地址直接对属性进行修改，可突破属性的访问修饰符限制


private String name;

@Test
public void test() {
    
    
        Unsafe unsafe = getUnsafe();
        try {
    
    
            DirectMemory directMemory = (DirectMemory) unsafe.allocateInstance(DirectMemory.class);
            long nameOffset = unsafe.objectFieldOffset(DirectMemory.class.getDeclaredField("name"));
            unsafe.putObject(directMemory, nameOffset, "luck");
            System.out.println(directMemory.getName());
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
}

2.2 操作数组元素

方法	功能
`public native int arrayBaseOffset(Class arrayClass)`	返回数组类型的第一个元素的偏移地址(基础偏移地址)
`public native int arrayIndexScale(Class arrayClass)`	返回数组中元素与元素之间的偏移地址的增量，配合 `arrayBaseOffset()` 使用就可以定位到任何一个元素的地址


private String[] names = {
    
    "nathan", "goog", "luck"};
  
@Test
public void test() {
    
    
        Unsafe unsafe = getUnsafe();
        try {
    
    
             Class<?> a = String[].class;
             int base = unsafe.arrayBaseOffset(a);
             int scale = unsafe.arrayIndexScale(a);
             // base + i * scale 即为字符串数组下标 i 在对象的内存中的偏移地址
             System.out.println(unsafe.getObject(names, (long) base + 2 * scale));
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
}

在 ForkJoinPool 中有一种新的元素定位算法，这种方法要求 scale 也就是元素的内存大小为 2 的次幂。假如 scale 等于 4，那么 ASHIFT 值为 2，乘以 4 和向左移 2 位结果是一样的，但是移位操作显然更高效
ASHIFT = 31 - Integer.numberOfLeadingZeros(scale)
offset = (i << ASHIFT) + ABASE

2.3 内存地址操作

方法	功能
`public native int addressSize()`	获取本地指针的大小(单位是byte)，通常值为 4 或者 8
`public native int pageSize()`	获取本地内存的页数，此值为2的幂次方
`public native long allocateMemory(long bytes)`	分配一块新的本地内存，通过bytes指定内存块的大小(单位是byte)，返回新开辟的内存的地址
`public native long reallocateMemory(long address, long bytes)`	通过指定的内存地址 address 重新调整本地内存块的大小，调整后的内存块大小通过bytes指定(单位为byte)
`public native void setMemory(Object o, long offset, long bytes, byte value)`	将给定内存块中的所有字节设置为固定值(通常是0)

public class DirectMemoryBuffer {
    
    
    private final static int BYTE = 1;
    private long size;
    private long address;
    private Unsafe unsafe;

    public DirectMemoryBuffer(long size, Unsafe unsafe) {
    
    
        this.size = size;
        this.unsafe = unsafe;
        address = unsafe.allocateMemory(size * BYTE);
    }

    public void set(long i, byte value) {
    
    
        unsafe.putByte(address + i * BYTE, value);
    }

    public int get(long idx) {
    
    
        return unsafe.getByte(address + idx * BYTE);
    }

    public long size() {
    
    
        return size;
    }

    public void freeMemory() {
    
    
        unsafe.freeMemory(address);
    }
}

2.4 CAS 操作

CAS 是一种乐观锁机制，它不需要抢占锁，能有效地提高效率，依赖于硬件的原子操作实现

方法	功能
`public final native boolean compareAndSwapObject(Object target, long offset, Object exceptData, Object targetData)`	其作用为比较目标对象指定偏移量的属性的期望值与主存中的值，如果二者相等，则将主存中的值更新为目标值。同样还有 `compareAndSwapInt() 和 compareAndSwapLong()`

public class CASCounter {
    
    
    private Unsafe unsafe;
    // count 需要声明为 volatile 来保证对所有线程可见
    private volatile long count = 0;
    private long offset;

    public CASCounter(Unsafe unsafe) {
    
    
        this.unsafe = unsafe;
        try {
    
    
            offset = unsafe.objectFieldOffset(CASCounter.class.getDeclaredField("count"));
        } catch (NoSuchFieldException e) {
    
    
            e.printStackTrace();
        }
    }

    // 关键的 increment 方法，其在 while 循环里不断尝试调用 compareAndSwapLong，在方法内部累加count的同时
    // 检查其值有没有被其他线程改变。如没有，就提交更改，如果不一致，那么继续尝试提交更改
    public void increment() {
    
    
        long before = count;
        while (!unsafe.compareAndSwapLong(this, offset, before, before + 1)) {
    
    
            before = count;
        }
    }

    public long getCount() {
    
    
        return count;
    }
}

2.5 线程挂起与恢复

方法	功能
`public native void park(boolean isAbsolute, long time)`	阻塞当前线程，一直等到 `unpark()`方法被调用或者超时，和 `Object.await()`非常类似，但是 park 是操作系统调用，因此在某些操作系统架构上这会带来更好的性能
`public native void unpark(Object thread)`	唤醒被 park 阻塞的线程，由于其不安全性，因此必须保证线程是存活的

2.6 内存屏障

方法	功能
`public native void loadFence()`	如果不要volatile去增加内存屏障，即可用该方法手动增加屏障。在该方法之前的所有读操作，一定在load屏障之前执行完成
`public native void storeFence()`	在该方法之前的所有写操作，一定在store屏障之前执行完成
`public native void fullFence()`	在该方法之前的所有读写操作，一定在 full 屏障之前执行完成，这个内存屏障相当于上面两个(load屏障和store屏障)的合体功能

2.7 Class 相关

方法	功能
`public native boolean shouldBeInitialized(Class<?> c)`	判断是否需要初始化一个类，通常在获取一个类的静态属性的时候使用（一个类如果没初始化，它的静态属性也不会初始化）。当且仅当ensureClassInitialized方法不生效时返回false
`public native void ensureClassInitialized(Class<?> c)`	检测给定的类是否已经初始化，通常在获取一个类的静态属性的时候使用（因为一个类如果没初始化，它的静态属性也不会初始化）
`public native Class<?> defineClass(String name, byte[] b, int off, int len, ClassLoader loader, ProtectionDomain protectionDomain)`	定义一个类，此方法会跳过JVM的所有安全检查，默认情况下 ClassLoader（类加载器）和 ProtectionDomain（保护域）实例来源于调用者
`public native Class<?> defineAnonymousClass(Class<?> hostClass, byte[] data, Object[] cpPatches)`	定义一个匿名类
`public native long staticFieldOffset(Field f)`	返回给定的静态属性在它的类的存储分配中的位置(偏移地址)
`public native Object staticFieldBase(Field f)`	返回给定的静态属性的位置，配合 `staticFieldOffset()`方法使用

Java UnSafe 类使用介绍

文章目录