前言
本文隶属于专栏《100个问题搞定Java虚拟机》,该专栏为笔者原创,引用请注明来源,不足和错误之处请在评论区帮忙指出,谢谢!
本专栏目录结构和参考文献请见100个问题搞定Java虚拟机
概述
在本文中,我们将讨论 sun.misc.Unsafe
。
该类为我们提供了底层的机制,这些机制旨在仅供核心 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()
方法。
它只会为我们的类分配内存,不会调用构造函数:
InitializationOrdering o3
= (InitializationOrdering) unsafe.allocateInstance(InitializationOrdering.class);
assertEquals(o3.getA(), 0);
请注意,由于没有调用构造函数,getA() 方法返回了 long 类型的默认值——0。
更改 private 字段
假设我们有一个有 private 字段的类:
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 将其值更改为任何其他 int 值。
抛出异常
通过 Unsafe 调用的代码不会像常规 Java 代码那样被编译器以同样的方式检查。
我们可以使用 throwException()
方法来抛出任何异常,而不会限制调用者必须处理该异常,即使它是受检的(checked)异常:
@Test(expected = IOException.class)
public void givenUnsafeThrowException_whenThrowCheckedException_thenNotNeedToCatchIt() {
unsafe.throwException(new IOException());
}
抛出经过检查的 IOException 后,我们不需要捕获它,也不需要在方法声明中指定它。
关于 Java 中异常的实现原理请参考我的博客——JVM是如何处理异常的?
堆外内存
如果应用程序在 JVM 上的可用内存用完了,我们最终可能会被迫频繁地 GC。
理想情况下,我们想要一个特殊的内存区域,在堆外并且不受 GC 程序控制。
Unsafe 类的 allocateMemory()
方法使我们能够从堆中分配大对象,同时 GC 和 JVM 不会看到和考虑这些内存。
这可能会非常有用,但我们需要记住,当不再需要时,需要手动管理此内存,并使用 freeMemory()
正确回收。
假设我们想创建巨大的堆外内存字节数组,我们可以使用 allocateMemory()
方法来实现:
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()
方法使用其索引检索字节值,该索引是数组起始地址的偏移量。
接下来,我们可以使用其构造函数来分配堆外内存的数组:
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.util.concurrent 软件包的非常高效的实现,如AtomicInteger,底层就是使用下面不安全的 compareAndSwap()方法,以提供最佳性能。
与 Java 中的标准悲观同步机制相比(如 sychronized),这种结构广泛应用于无锁(lock-free)算法中,这些算法可以利用 CAS 处理器指令极大的加速我们的程序。
我们可以使用 Unsafe 的 compareAndSwapLong()
方法构建基于 CAS 的计数器:
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()
方法中使用它。
该字段需要声明为volatile
,以便对正在编写和读取此值的所有线程可见。
关于
volatile
请参考我的博客——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())));
接下来,要断言(assert)计数器的状态是正确的,我们可以从中获取计数器值:
assertEquals(NUM_OF_INCREMENTS * NUM_OF_THREADS, casCounter.getCounter());
Park/Unpark
Unsafe API 中有两个方法,通常被 JVM 用来上下文切换线程。
当线程等待某些操作时,JVM 可以使用 Unsafe 类的park()
方法阻塞该线程。
当线程被阻塞并需要再次运行时,JVM 使用 unpark()
方法。
这里举一个典型的例子,LockSupport 中的 park/unpark 底层就是调用的 Unsafe API 中的 park/unpark。
关于 LockSupport 请参考我的博客——LockSupport 是什么?怎么用?