1.Unsafe综述

作用： Unsafe是个后门类，封装了一些类似指针的操作，提供了一些可以直接操控内存和线程的底层操作
使用： Unsafe被JDK广泛用于nio包和并发包中，但是不建议在生产环境使用，风险太大
不安全： 不安全指的是指针的操作不安全(Java因此才把指针去掉)，若指针指错位置或计算指针偏移量出错，结果不可想象，比如说覆盖了别人的内存，那可能就GG思密达了...

• Unsafe类是在sun.misc包下，不属于Java标准，android中也不是标准支持，可以通过使用java库的方式+反射调用
• 另外可以用LockSupport类+Atomic原子类操作来代替Unsafe类的功能，其时CAS操作的基石；
• Unsafe类使Java拥有了像C语言的指针一样操作内存空间的能力，一旦能够直接操作内存，因此操作时，需要对象地址，对象成员变量相对地址偏移量，旧值，要修改后的值；

两个方面的用途

• 线程的停止、唤醒
• 基础数据、对象的写，具有原子性

2.Unsafe的数据结构

2.1 类定义

public final class Unsafe

2.2 构造器

//私有构造器 --单例模式
private Unsafe() {}

2.3 重要变量

private static final Unsafe theUnsafe;
public static final int INVALID_FIELD_OFFSET = -1;
public static final int ARRAY_BOOLEAN_BASE_OFFSET;
public static final int ARRAY_BYTE_BASE_OFFSET;
public static final int ARRAY_SHORT_BASE_OFFSET;
public static final int ARRAY_CHAR_BASE_OFFSET;
public static final int ARRAY_INT_BASE_OFFSET;
public static final int ARRAY_LONG_BASE_OFFSET;
public static final int ARRAY_FLOAT_BASE_OFFSET;
public static final int ARRAY_DOUBLE_BASE_OFFSET;
public static final int ARRAY_OBJECT_BASE_OFFSET;
public static final int ARRAY_BOOLEAN_INDEX_SCALE;
public static final int ARRAY_BYTE_INDEX_SCALE;
public static final int ARRAY_SHORT_INDEX_SCALE;
public static final int ARRAY_CHAR_INDEX_SCALE;
public static final int ARRAY_INT_INDEX_SCALE;
public static final int ARRAY_LONG_INDEX_SCALE;
public static final int ARRAY_FLOAT_INDEX_SCALE;
public static final int ARRAY_DOUBLE_INDEX_SCALE;
public static final int ARRAY_OBJECT_INDEX_SCALE;
public static final int ADDRESS_SIZE;
private static native void registerNatives();
static {
    registerNatives();
    Reflection.registerMethodsToFilter(Unsafe.class, new String[]{"getUnsafe"});
    theUnsafe = new Unsafe();//单例模式 -饿汉式
    ARRAY_BOOLEAN_BASE_OFFSET = theUnsafe.arrayBaseOffset(boolean[].class);
    ARRAY_BYTE_BASE_OFFSET = theUnsafe.arrayBaseOffset(byte[].class);
    ARRAY_SHORT_BASE_OFFSET = theUnsafe.arrayBaseOffset(short[].class);
    ARRAY_CHAR_BASE_OFFSET = theUnsafe.arrayBaseOffset(char[].class);
    ARRAY_INT_BASE_OFFSET = theUnsafe.arrayBaseOffset(int[].class);
    ARRAY_LONG_BASE_OFFSET = theUnsafe.arrayBaseOffset(long[].class);
    ARRAY_FLOAT_BASE_OFFSET = theUnsafe.arrayBaseOffset(float[].class);
    ARRAY_DOUBLE_BASE_OFFSET = theUnsafe.arrayBaseOffset(double[].class);
    ARRAY_OBJECT_BASE_OFFSET = theUnsafe.arrayBaseOffset(Object[].class);
    ARRAY_BOOLEAN_INDEX_SCALE = theUnsafe.arrayIndexScale(boolean[].class);
    ARRAY_BYTE_INDEX_SCALE = theUnsafe.arrayIndexScale(byte[].class);
    ARRAY_SHORT_INDEX_SCALE = theUnsafe.arrayIndexScale(short[].class);
    ARRAY_CHAR_INDEX_SCALE = theUnsafe.arrayIndexScale(char[].class);
    ARRAY_INT_INDEX_SCALE = theUnsafe.arrayIndexScale(int[].class);
    ARRAY_LONG_INDEX_SCALE = theUnsafe.arrayIndexScale(long[].class);
    ARRAY_FLOAT_INDEX_SCALE = theUnsafe.arrayIndexScale(float[].class);
    ARRAY_DOUBLE_INDEX_SCALE = theUnsafe.arrayIndexScale(double[].class);
    ARRAY_OBJECT_INDEX_SCALE = theUnsafe.arrayIndexScale(Object[].class);
    ADDRESS_SIZE = theUnsafe.addressSize();
}

3.Unsafe重要方法

//获得给定对象内存偏移量的int值
public native int getInt(Object var1, long var2);
//设置给定对象内存偏移量的int值
public native void putInt(Object var1, long var2, int var4);
public native Object getObject(Object var1, long var2);
public native void putObject(Object var1, long var2, Object var4);
//....还有Boolean、Byte、Char、Short、Long、Float、Double的get\set....
//内存分配、释放
//分配内存
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 void setMemory(long var1, long var3, byte var5) {
    this.setMemory((Object)null, var1, var3, var5);
}
//拷贝内存
public native void copyMemory(Object var1, long var2, Object var4, long var5, long var7);
public void copyMemory(long var1, long var3, long var5) {
    this.copyMemory((Object)null, var1, (Object)null, var3, var5);
}
//释放内存
public native void freeMemory(long var1);
//获取字段在对象中的内存偏移量
public native long staticFieldOffset(Field var1);
public native long objectFieldOffset(Field var1);
public native Object staticFieldBase(Field var1);
public native void ensureClassInitialized(Class<?> var1);
//数组元素定位
//arrayBaseOffset 和 arrayIndexScale 搭配使用可以定位数组中每个元素在内存中的位置
//获取数组第一个元素的偏移地址
public native int arrayBaseOffset(Class<?> var1);
//获取数组的转换因子，也就是数组中元素的增量地址
public native int arrayIndexScale(Class<?> var1);
public native int addressSize();
public native int pageSize();
//类定义
public native Class<?> defineClass(String var1, byte[] var2, int var3, int var4, ClassLoader var5, ProtectionDomain var6);
public native Class<?> defineClass(String var1, byte[] var2, int var3, int var4);
public native Class<?> defineAnonymousClass(Class<?> var1, byte[] var2, Object[] var3);
//创建实例
public native Object allocateInstance(Class<?> var1) throws InstantiationException;
//Synchronized同步块的指令实现 1.8版的全部是@Deprecated
public native void monitorEnter(Object var1);
public native void monitorExit(Object var1);
public native boolean tryMonitorEnter(Object var1);
//异常抛出
public native void throwException(Throwable var1);
//CAS操作
/**
* 比较obj的offset处内存位置中的值和期望的值，如果相同则更新，此更新是不可中断的
* @param obj 需要更新的对象
* @param offset obj中整型field的偏移量
* @param expect 希望field中存在的值
* @param update 如果期望值expect与field的当前值相同，设置filed的值为这个新值
* @return 如果field的值被更改返回true
*/
public final native boolean compareAndSwapObject(Object obj, long offset, Object expect, Object update);
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);
//获取给定对象的指定类型值，支持volatile load语义
public native Object getObjectVolatile(Object var1, long var2);
public native void putObjectVolatile(Object var1, long var2, Object var4);
public native int getIntVolatile(Object var1, long var2);
//设置给定对象的int值，支持volatile load语义
public native void putIntVolatile(Object var1, long var2, int var4);
//....还有Boolean、Byte、Char、Short、Long、Float、Double的volatile级别的get\put....
public native void putDoubleVolatile(Object var1, long var2, double var4);
public native void putOrderedObject(Object var1, long var2, Object var4);
public native void putOrderedInt(Object var1, long var2, int var4);
public native void putOrderedLong(Object var1, long var2, long var4);
//LockSupport类的原语支持-挂起和唤醒某个线程
public native void unpark(Object var1);
public native void park(boolean var1, long var2);
public native int getLoadAverage(double[] var1, int var2);
//提供线程安全的add和set操作
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
    do {
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
    return var5;
}
public final int getAndSetInt(Object var1, long var2, int var4) {
    int var5;
    do {
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var4));
    return var5;
}
//...还有Long和Object的线程安全的add和set操作...
//栅栏支持
public native void loadFence();
public native void storeFence();
public native void fullFence();

4.Unsafe的使用

4.1 UnSafe的使用限制

4.1.1 私有构造器

private Unsafe() {}

4.1.2 禁用的工厂方法

@CallerSensitive
public static Unsafe getUnsafe() {
    Class var0 = Reflection.getCallerClass();
    //该方法用于判断调用者的类加载器是否是系统核心加载器（即Bootstrap加载器）
    if(!VM.isSystemDomainLoader(var0.getClassLoader())) {
        throw new SecurityException("Unsafe");
    } else {
        return theUnsafe;
    }
}

我们先显性调用该工厂方法查看一下调用结果

package concurrent;
import sun.misc.Unsafe;
public class UnsafeDemo {
    public static void main(String[] args) {
        Unsafe.getUnsafe();
    }
}
-------------------
//输出：
Exception in thread "main" java.lang.SecurityException: Unsafe
    at sun.misc.Unsafe.getUnsafe(Unsafe.java:90)
    at concurrent.UnsafeDemo.main(UnsafeDemo.java:7)
//分析：可以发现直接调用的话会直接抛出安全异常，原因是类加载器是AppClassLoader而并非是BootstrapLoader  

4.2 Unsafe的反射获取

/** 
  * 我们可以通过反射机制获取Unsafe 的一个实例
  */
public static Unsafe getUnsafe(){
    try {
        //通过反射获取Unsafe的theUnsafe变量，即Unsafe实例对象
        Field f = Unsafe.class.getDeclaredField("theUnsafe");
        f.setAccessible(true);
        //注意field是static属性
        //参见：private static final Unsafe theUnsafe;
        return (Unsafe) f.get(null);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

3 AtomicInteger的代码

这时AtomicInteger的代码：首先静态获取变量相对类的偏移量，在对象处理时，使用当前对象地址+偏移量，推算出当前变量地址

    private static final sun.misc.Unsafe U = sun.misc.Unsafe.getUnsafe();
    private static final long VALUE;

    static {
        try {
            VALUE = U.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (ReflectiveOperationException e) {
            throw new Error(e);
        }
    }

    private volatile int value;
    
    public final boolean compareAndSet(int expect, int update) {
        return U.compareAndSwapInt(this, VALUE, expect, update);
    }

代码解读：

• VALUE 为value变量在AtmicInteger实例地址的相对偏移量,这个相对偏移量对于类，在类加载后就是一定的
• U提供了设置方法，但是为了保证读写操作的原子性，我们一般选择使用volatile+和旧值比对然后替换的方法来达到原子性
• 和旧值比对，如果一致，替换才能成功，否则不能成功

原子性的原理：

• 读的结果为最新
• 写的时候，旧值符合预期才能成功，如果变动了则旧值旧变化了，也就不能写成功了 存在问题ABA问题，也就是旧值在一个线程变为A，让后在另外一个线程变为B，某个线程为A；你当时获取为A，那么也是可以修改为你想要的了；这个问题是添加时间戳来记录旧值并比对

参考

并发番@Unsafe一文通（1.8版）
AbstractQueuedSynchronizer原理解析