一、概览
在这篇文章中，我们将介绍一个由JRE提供的很有趣的类---sun.misc.包下的Unsafe。这个类为我们提供了底层机制，这些底层机制原本是设计用来供Java核心类库使用的，而非普通Java用户。
二、获取Unsafe的实例
首先，要想使用Unsafe类，我们需要获取一个实例-该实例并没有直接给出，因为这个类是设计用来为内部使用的。获取该实例的方式就是通过getUnsafe()方法。默认的警告-它会抛出一个SecurityException。
幸运地是，我们可以使用反射来获取该实例：
Field f = Unsafe.class.getDeclaredField("theUnsafe");
f.setAccessible(true);
unsafe = (Unsafe) f.get(null);
三、使用Unsafe实例化一个类
现在我们有一个简单类，它的构造函数会在对象创建的时候，设置一个变量值：
class InitializationOrdering {
private long a;
public InitializationOrdering() {
this.a = 1;
}
public long getA() {
return this.a;
}
}
当我们使用它的构造函数初始化它时，其getA()方法的返回值为1：
InitializationOrdering o1 = new InitializationOrdering();
assertEquals(o1.getA(), 1);
但是，我们也可以使用Unsafe的allocateInstance()方法，它只会为此类分配内存，而不会调用其构造函数：
Field f = Unsafe.class.getDeclaredField("theUnsafe");
f.setAccessible(true);
Unsafe unsafe = (Unsafe) f.get(null);
InitializationOrdering o3
= (InitializationOrdering) unsafe.allocateInstance(InitializationOrdering.class);
assertEquals(o3.getA(), 0);
可以看到构造函数并没有被调用，因为getA()方法的返回值是long类型的默认值-即值为0。
四、修改私有变量
假如说我们有一个类，该类持有了一个私有变量：
class SecretHolder {
private int SECRET_VALUE = 0;
public boolean secretIsDisclosed() {
return SECRET_VALUE == 1;
}
}
使用Unsafe的putInt()方法，我们可以改变私有变量SECRET_VALUE 的值，改变/破坏该实例的状态：
SecretHolder secretHolder = new SecretHolder();
Field f = secretHolder.getClass().getDeclaredField("SECRET_VALUE");
unsafe.putInt(secretHolder, unsafe.objectFieldOffset(f), 1);
assertTrue(secretHolder.secretIsDisclosed());
一旦我们通过反射拿到了某个字段之后，我们就可以使用Unsafe修改它的值。
五、抛出异常
通过Unsafe调用的代码不会像正常的Java代码一样被编译器检查。我们可以使用throwException()方法抛出任何的异常，而无需限制用户处理该异常，即使它是检查异常：
@Test(expected = IOException.class)
public void givenUnsafeThrowException_whenThrowCheckedException_thenNotNeedToCatchIt() {
unsafe.throwException(new IOException());
}
在抛出IOException之后，我们既不需要捕获它也不需要在方法声明上指定。
六、Off-heap 内存
如果某个应用正在耗尽JVM可用内存的话，我们会强制GC进程频繁运行。理想情况下，我们可以想要一个特殊的内存区域，off-heap并且不被GC进程控制。
Unsafe类的allocateMemory()方法使我们有能力把大量的对象分配在堆内存之外，这意味着该内存不会被GC看到，也不会被GC管理。
这可能很有用，但是我们需要记住，当我们不用的时候，我们需要手动地管理好这片内存，使用freeMemory()对其进行回收。
比如说，我们想创建大量堆外字节数组。我们可以使用使用allocateMemory()函数来实现：
public class OffHeapArray {
private final static int BYTE = 1;
private long size ;
private long address;
public OffHeapArray(long size ) throws NoSuchFieldException,IllegalAccessException{
this.size = size;
address = getUnsafe().allocateMemory(size * BYTE);
}
private Unsafe getUnsafe() throws IllegalAccessException,NoSuchFieldException {
Field f= Unsafe.class.getDeclaredField("theUnsafe");
f.setAccessible(true);
return (Unsafe) f.get(null);
}
public void set(long i, byte value) throws NoSuchFieldException,IllegalAccessException{
getUnsafe().putByte(address + i * BYTE,value);
}
public int get(long idx) throws NoSuchFieldException,IllegalAccessException{
return getUnsafe().getByte(address + idx * BYTE);
}
public long size (){
return size;
}
public void freeMemory() throws NoSuchFieldException,IllegalAccessException{
getUnsafe().freeMemory(address);
}
}
在OffHeapArray的构造函数中，我们以给定的大小初始化数组。我们把数组的起始地址保存在address字段中。set()方法接收了脚标，以及要在数组中存储的值。get()方法使用脚标来获取值。
下一步，我们可以使用它的构造函数分配一个off-heap数组：
long SUPER_SIZE = (long) Integer.MAX_VALUE * 2;
OffHeapArray array = new OffHeapArray(SUPER_SIZE);
我们可以把N个字节的值放入该数组中，并且取回这些值，把他们加起来，检查一下我们的地址是不是可以正常的工作：
int sum = 0;
for (int i = 0; i < 100; i++) {
array.set((long) Integer.MAX_VALUE + i, (byte) 3);
sum += array.get((long) Integer.MAX_VALUE + i);
}
assertEquals(array.size(), SUPER_SIZE);
assertEquals(sum, 300);
最后，我们需要调用freeMemory()方法手动地把内存释放给操作系统。
七、CompareAndSwap 操作
java.concurrent包下许多高效的构造函数，像 AtomicInteger，在本质上使用的就是Unsafe的CompareAndSwap()方法，以提供最佳的性能。该构造在lock-free算法中被广泛使用，相较于java的悲观锁，它可以利用CAS处理器指令提供更快的速度。
我们构造一个基于CAS的counter，使用Unsafe的compareAndSwapLong()方法：
class CASCounter {
private Unsafe unsafe;
private volatile long counter = 0;
private long offset;
private Unsafe getUnsafe() throws IllegalAccessException, NoSuchFieldException {
Field f = Unsafe.class.getDeclaredField("theUnsafe");
f.setAccessible(true);
return (Unsafe) f.get(null);
}
public CASCounter() throws Exception {
unsafe = getUnsafe();
offset = unsafe.objectFieldOffset(CASCounter.class.getDeclaredField("counter"));
}
public void increment() {
long before = counter;
while (!unsafe.compareAndSwapLong(this, offset, before, before + 1)) {
before = counter;
}
}
public long getCounter() {
return counter;
}
}
在CASCounter的构造函数中，我们得到了counter字段的地址，以便于在后面的increment()方法中使用。我们需要把counter字段声明为volatile以便对其他正在读写的线程可见。我们使用objectFieldOffset()方法得到了offset字段的内存地址。
该类最重要的部分是increment()方法，我们在while循环中使compareAndSwapLong()把之前获取的值自增，并检查该值自我们上次获取它之后，有没有发生改变。
如果它发生了改变了的话，我们就不断重试直到成功。这里没有阻塞操作，这也就是它为什么被称为lock-free算法的原因。
我们可以在多线程中测试我们的代码：
int NUM_OF_THREADS = 1_000;
int NUM_OF_INCREMENTS = 10_000;
ExecutorService service = Executors.newFixedThreadPool(NUM_OF_THREADS);
CASCounter casCounter = new CASCounter();
IntStream.rangeClosed(0, NUM_OF_THREADS - 1)
.forEach(i -> service.submit(() -> IntStream
.rangeClosed(0, NUM_OF_INCREMENTS - 1)
.forEach(j -> casCounter.increment())));
下一步，我们可以获取该计数器的值，判断它的状态是不是正确：
assertEquals(NUM_OF_INCREMENTS * NUM_OF_THREADS, casCounter.getCounter());
八、Park/Unpark
在Unsafe的API中，还有两个比较有趣的方法，JVM会使用它们完成线程的上下文切换。
当线程在等待某些动作的时候，JVM可以使用Unsafe类的park()方法把该线程阻塞住。
@Test
public void testPark() throws Exception {
final boolean[] run = new boolean[1];
Thread thread = new Thread() {
@Override
public void run() {
unsafe.park(true, 100000L);
run[0] = true;
}
};
thread.start();
unsafe.unpark(thread);
thread.join(100L);
assertTrue(run[0]);
}
park方法和Object.wait()方法很相似，但是它是在本地OS代码层面调用的，因此可以利用
一些架构细节获取最佳性能。
当线程被阻塞后，如果需要使它重新变成runnable的话，JVM会使用unpark()方法。我们经常
在线程的堆栈中看到这些方法调用，尤其是使用了线程池的那些应用。
九、总结
在本文中，我们研究了Unsafe类及其最有用的构造。
我们了解了如何访问私有字段，如何分配堆外内存，以及如何使用compare-and-swap来实现无锁算法。
