Java：Unsafe类的使用

一、获取Unsafe类实例

    Field field = Unsafe.class.getDeclaredField("theUnsafe");
    field.setAccessible(true);
    return (Unsafe) field.get(null);    

 theUnsafe 是Unsafe内部的一个字段，Unsafe在静态代码块中实例化一个Unsafe类，并通过反射获取Unsafe。

还有一个是Unsafe.getUnsafe静态方法也是获取Unsafe实例的，不过这个getUnsafe方法会检查类加载器类型，如果非Bootstrap Classloader就会抛SecurityException异常。

 二、使用Unsafe来实例化一个类

class InitializationOrdering {
    private long a;

    public InitializationOrdering() {
        this.a = 1;
    }

    public long getA() {
        return this.a;
    }
}

使用 new 构造函数初始化该对象时， getA() 方法将返回值1，可以使用Unsafe使用 allocateInstance() 方法。它只会为我们的类分配内存，不会调用构造函数：

        InitializationOrdering o3 = null;
        try {
            o3 = (InitializationOrdering) THE_UNSAFE.allocateInstance(InitializationOrdering.class);
            // 构造函数没有被调用, 因此, getA()方法返回了long类型的默认值——0
            if (o3.getA() == 0) {
                System.out.println("不会调用InitializationOrdering构造函数获取到的a为0");
            }
        } catch (InstantiationException e) {
            e.printStackTrace();
        }

三、改变私有字段

class SecretHolder {
    private int SECRET_VALUE = 0;

    public boolean secretIsDisclosed() {
        return SECRET_VALUE == 1;
    }
}

通过Unsafe类的 putInt() 方法修改SecretHolder的私有整形字段。

        SecretHolder secretHolder = new SecretHolder();
        try {
            Field f = secretHolder.getClass().getDeclaredField("SECRET_VALUE");

            THE_UNSAFE.putInt(secretHolder, THE_UNSAFE.objectFieldOffset(f), 1);

            if(secretHolder.secretIsDisclosed()){
                System.out.println("Unsafe改变了私有字段的值, 改成了1");
            }
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }

四、抛出异常

        // 抛出异常, 使用throwException()方法抛出任何异常而不限制调用者处理该异常
        THE_UNSAFE.throwException(new IOException());

五、堆外内存

应用程序在 JVM 上的可用内存不足，我们最终可能会迫使 GC 进程过于频繁地运行。想在GC时减少回收停顿对于应用的影响，我们需要一个特殊的内存区域，在堆外并且不受 GC 进程控制。

Unsafe的 allocateMemory() 方法能够让我们能够在堆外给一个比较大的对象分配内存，这代表这这些内存不会GC和JVM看到或者纳入它们的管理，而是由操作系统进行管理的。对于需要频繁进行内存间数据拷贝且生命周期较短的暂存数据，都建议存储到堆外内存，比如I/O通信过程。

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);
    }
}

使用 allocateMemory 分配内存，并往分配的内存中 putByte 进去一个3（转byte），并且 getByte 循环100次并求和，最后看sum结果是否为300.。

        long SUPER_SIZE = (long) Integer.MAX_VALUE * 2;
        try {
            OffHeapArray array = new OffHeapArray(SUPER_SIZE);

            int sum = 0;
            // 将 N 个字节值放入这个数组，然后检索这些值，将它们相加以测试我们的寻址是否正常工作
            for (int i = 0; i < 100; i++) {
                array.set((long) Integer.MAX_VALUE + i, (byte) 3);
                sum += array.get((long) Integer.MAX_VALUE + i);
            }
            if (array.size() == SUPER_SIZE) {
                System.out.println("数组大小为SUPER_SIZE");
            }

            if (sum == 300) {
                System.out.println("数组总和为300");
            }
        } catch (NoSuchFieldException | IllegalAccessException e) {
            e.printStackTrace();
        }

六、ComparedAndSwap操作

class CASCount {
    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);
    }

    CASCount() throws Exception {
        unsafe = getUnsafe();
        offset = unsafe.objectFieldOffset(CASCount.class.getDeclaredField("counter"));
    }

    /**
     * 使用Unsafe中的CompareAndSwapLong方法构建基于CAS计数器
     */
    public void increment() {
        long before = counter;
        while (!unsafe.compareAndSwapLong(this, offset, before, before + 1)) {
            before = counter;
        }
    }

    public long getCounter() {
        return counter;
    }
}

获取计数器字段的地址，以便稍后在 increment 方法中使用它，在while循环中使用 compareAndSwapLong 来增加先前获取的值，可以通过增加多个线程的共享计数器来测试。

        int NUM_OF_THREAD = 1_10;
        int NUM_OF_INCREMENT = 10_100;
        ExecutorService service = Executors.newFixedThreadPool(NUM_OF_THREAD);

        try {
            CASCount casCount = null;
            casCount = new CASCount();
            CASCount finalCasCount = casCount;
            IntStream.rangeClosed(0, NUM_OF_THREAD - 1)
                    .forEach(i -> service.submit(() -> IntStream
                            .rangeClosed(0, NUM_OF_INCREMENT - 1)
                            .forEach(j -> finalCasCount.increment())));
            System.out.println("NUM_OF_THREAD:" + NUM_OF_THREAD);
            System.out.println("NUM_OF_INCREMENT:"+ NUM_OF_INCREMENT);
            System.out.println(NUM_OF_THREAD * NUM_OF_INCREMENT == casCount.getCounter());
        } catch (Exception e) {
            e.printStackTrace();
        }

七、Park & Unpark

Unsafe API 中有两种的方法，JVM 使用它们来上下文切换线程。当线程正在等待某个动作时，JVM 可以使用Unsafe类中的 park() 方法使该线程阻塞。它与 Object.wait() 方法非常相似，但它调用本机操作系统代码，从而利用一些架构细节来获得最佳性能。当线程被阻塞并需要再次运行时，JVM 使用 unpark() 方法。