Unsafe类是进行底层操作的方法集合，可以直接操作内存，进行一些非常规操作，所以说是"不安全"的操作，但是因为直接操作内存，它的效率很高，通常在在对性能有要求或者有底层操作需求的时候使用
Unsafe的包名为sun.misc，Java9开始，位于jdk.unsupported模块内，并且添加大量注释方便使用，同时在jdk.internal模块内有一个更底层的Unsafe类实现
Unsafe 实例化
因为Unsafe的构造函数是private，所以不能使用new创建，Unsafe使用单例模式构建，内部实例字段名称为theUnsafe
private Unsafe() {}
private static final Unsafe theUnsafe = new Unsafe();
private static final jdk.internal.misc.Unsafe theInternalUnsafe = jdk.internal.misc.Unsafe.getUnsafe();
Unsafe.getUnsafe静态方法可以返回该字段，但是Java9之前，只有调用该方法的类是通过引导类加载器（bootstrap class loader）加载的才可以获取该字段（此时caller.getClassLoader()返回值为null），即JDK源码可以正常调用，个人写的代码都会抛出异常SecurityException
// Java8
@CallerSensitive
public static Unsafe getUnsafe() {
Class<?> caller = Reflection.getCallerClass();
if (!VM.isSystemDomainLoader(caller.getClassLoader()))
throw new SecurityException("Unsafe");
return theUnsafe;
}
// Java9
public static Unsafe getUnsafe() {
return theUnsafe;
}
为此可以将引导类加载器路径设置为系统默认值加上自身代码的当前路径
java -Xbootclasspath:/usr/lib/jvm/jdk1.8.0/jre/lib/rt.jar:. MainClassName
但是这样太过麻烦，所以在Java8及以前，直接使用反射获取该theUnsafe字段，抑制Java语言的访问检查（private属性），获取字段的值
Field f = Unsafe.class.getDeclaredField("theUnsafe");
f.setAccessible(true);
Unsafe unsafe = (Unsafe) f.get(null);
Unsafe API
大多数API都是通过native函数实现的，具体可以查看源码中的文件path/to/openjdk/source/hotspot/src/share/vm/prims/unsafe.cpp
Classes/Objects
创建类对象，不进行初始化：
//实例化对象，但是不进行初始化，类初始化和实例初始化都不调用
Object allocateInstance(Class<?> cls)
对象和字段的地址获取：
//字段在内存中的地址相对于实例对象内存地址的偏移量
public long objectFieldOffset(Field f)
public long objectFieldOffset(Class<?> c, String name)
//静态字段在类对象中的偏移
public long staticFieldOffset(Field f)
//获得静态字段所对应类对象，等同于f.getDeclaringClass()
public Object staticFieldBase(Field f)
读取/修改对象上指定偏移位置的值，其他基本数据类型(boolean,char,byte,short,float,double,long)类似：
public native int getInt(Object o, long offset);
public native void putInt(Object o, long offset, int x);
此外还可以读取/设定引用值reference value,指针native pointer
//获得给定对象偏移量上的引用类型的值
public native Object getObject(Object o, long offset);
//设置给定对象偏移量上的引用类型的值
public native void putObject(Object o, long offset, Object x);
//获取、设定本地指针的值，等同于获取、设定int或者是long类型的数据
public long getAddress(Object o, long offset)
public void putAddress(Object o, long offset, long x)
以上方法都是通过两个参数引用到一个变量，叫做double-register地址模式，
当Object引用为null时，把offset作为绝对地址，使用绝对地址的API，叫做single-register地址模式，例如：
public void putInt(long address, int x) {
putInt(null, address, x);
}
此时address可以指向通过Unsafe.allocateMemory获取的内存块中的地址，类似于C语言中的指针，直接指明实际要读写的地址
Arrays
数组头部还存储有数组的长度信息，索引访问数组元素时需要知道第一个元素与起始位置的偏移地址，Unsafe类包含所有的基本数据类型和Object类型的偏移的常量值，名称为ARRAY_***_BASE_OFFSET
同时访问数组第i个元素，对应偏移的确定需要乘以一个比例值，即数组中单个元素的长度，Unsafe中对应的常量为ARRAY_***_INDEX_SCALE
// 初始偏移
public int arrayBaseOffset(Class<?> arrayClass)
public static final int ARRAY_BOOLEAN_BASE_OFFSET
= theUnsafe.arrayBaseOffset(boolean[].class);
public static final int ARRAY_OBJECT_BASE_OFFSET
= theUnsafe.arrayBaseOffset(Object[].class);
// 比例值
public int arrayIndexScale(Class<?> arrayClass)
public static final int ARRAY_BOOLEAN_INDEX_SCALE
= theUnsafe.arrayIndexScale(boolean[].class);
public static final int ARRAY_OBJECT_INDEX_SCALE
= theUnsafe.arrayIndexScale(Object[].class);
两个信息配合使用，就可以得到数组中每个元素相对内存起点的偏移，然后进行读写
// java8中的ConcurrentHashMap
Class<?> ak = Node[].class;
ABASE = U.arrayBaseOffset(ak);
int scale = U.arrayIndexScale(ak);
ASHIFT = 31 - Integer.numberOfLeadingZeros(scale);
//具体使用，i代表索引
static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
Node<K,V> c, Node<K,V> v) {
return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
}
Synchronization
CAS操作
只有Object，int和long类型，对于其他基本数据类型，可以对数据进行转换为以上三种数据类型，再进行CAS
public final native boolean compareAndSwapObject(Object o, long offset, Object expected, Object x);
public final native boolean compareAndSwapInt(Object o, long offset, int expected, int x);
public final native boolean compareAndSwapLong(Object o, long offset, long expected, long x);
JDK8中添加了一些对基本数据类型进行循环CAS操作，确保成功的功能函数
@HotSpotIntrinsicCandidate
public final int getAndAddInt(Object o, long offset, int delta) {
int v;
do {
v = getIntVolatile(o, offset);
} while (!weakCompareAndSetInt(o, offset, v, v + delta));
return v;
}
@HotSpotIntrinsicCandidate
public final int getAndSetInt(Object o, long offset, int newValue) {
int v;
do {
v = getIntVolatile(o, offset);
} while (!weakCompareAndSetInt(o, offset, v, newValue));
return v;
}
volatile
使用volatile机制加载读取数据，保证可见性，API包含所有的基本数据类型和Object类型
//设置给定对象的int值，使用volatile语义，即设置后立马更新到内存对其他线程可见
public native void putIntVolatile(Object o, long offset, int x);
//获得给定对象的指定偏移量offset的int值，使用volatile语义，总能获取到最新的int值。
public native int getIntVolatile(Object o, long offset);
此外还有一种惰性设定值的方式，通常出现在AtomicXXX.lazySet，它允许volatile变量和后续的内存操作重排序，就像普通非volatile变量的写操作，所以其他线程可能不能立即获取到新的值
putOrderedObject(Object o, long offset, Object x)
putOrderedInt(Object o, long offset, int x)
putOrderedLong(Object o, long offset, long x)
挂起
调用park后，线程将被阻塞，直到unpark调用或者超时，如果之前调用过unpark,不会进行阻塞，即park和unpark不区分先后顺序，该操作被封装在LockSupport类中
// 阻塞线程
public native void park(boolean isAbsolute, long time);
// 解除阻塞或者让下一次阻塞调用失效
public native void unpark(Object thread);
内存屏障
确保内存可见性，在适当的位置插入内存屏障，JMM把内存屏障分为4种LoadLoad、LoadStore、StoreStore、StoreLoad
//在屏障之前的读操作，不会和之后的读写操作重排序，相当于LoadLoad 加上 LoadStore 屏障
public native void loadFence();
//在屏障之前的读写操作，不会和之后的写操作重排序，相当于StoreStore 加上 LoadStore 屏障
public native void storeFence();
//在该方法之前的所有读写操作，不会和之后的读写操作重排序，功能上相当于上面两个的功能和，加上StoreLoad屏障
public native void fullFence();
Memory
包括内存的分配，释放，复制
//分配指定大小的内存,内存没有被初始化
public long allocateMemory(long bytes)
//根据给定的内存地址address调整内存大小
public long reallocateMemory(long address, long bytes)
//将内存块中的所有字节设置为固定值，类似于C中的memoryset函数
public void setMemory(Object o, long offset, long bytes, byte value)
public void setMemory(long address, long bytes, byte value)
//内存复制，支持两种地址模式
public void copyMemory(Object srcBase, long srcOffset,
Object destBase, long destOffset,
long bytes)
public void copyMemory(long srcAddress, long destAddress, long bytes)
//释放allocateMemory和reallocateMemory申请的内存
public native void freeMemory(long l);
内存的其他信息：
// 本地指针的大小 native pointer,4 或者 8
public int addressSize()
// 内存页面大小，通常为4KB，即4096
public native int pageSize()
