详解java中的Unsafe

最新推荐文章于 2024-06-29 19:35:08 发布

Sunday1105

最新推荐文章于 2024-06-29 19:35:08 发布

阅读量357

点赞数

分类专栏： java 文章标签： java 安全

本文链接：https://blog.csdn.net/Sunday1105/article/details/108653001

版权

java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

概述

本文是学习笔记，主要是对baeldung和oracle官文的学习试验总结

Unsafe，提供了主要为核心库内部使用而设计的底层机制。Java 8的 Unsafe类，位于sun.misc.Unsafe包，sun.misc包是一个内部包，实现特殊场景，一般java代码是不能直接接触到的，在Java 9 和往后的版本，包更加清晰的声明，Unsafe被移到了jdk.unsupported的包下。

有时，我们可能需要打破既定的规则。在Java平台中，这通常通过使用三种主要机制之一来完成:反射、类加载(包括相关的字节码转换)和Unsafe，本文主要介绍的是Unsafe

Java的进阶用户应该理解这三种技术，即使只是在必要时才使用它们。在这三种方法中，Unsafe是最具潜在危险的(因此也是最强大的)，它破坏了平台的既定规则，因为它提供了一种方式来做某些规则不允许的事情

例如，Unsafe允许开发者：

直接访问CPU和其他硬件功能
创建对象，但不运行其构造函数
创建一个真正的匿名类，而不需要通常的验证
手动管理堆外内存
还有其他一些看似不可能的事情

尽管有这些明显的危险信号，但Unsafe令人难以忽视，它已经变得无处不在。实际上Java生态系统中的每个主要框架都依赖于Unsafe提供的一个或多个功能。毫不夸张地说，现代Java开发人员所期望的动态性、灵活性和性能在很大程度上源于以某种形式使用Unsafe

实例化Unsafe的实例

Unsafe的构造方法是private，不能直接用new实例化。为了能够使用Unsafe类，我们需要获得一个实例，由于Unsafe类只是为内部使用而设计的。如果我们获取实例的方法是通过静态方法getUnsafe()，这将抛出一个SecurityException，

但是，我们可以使用反射获得实例：

Field f = Unsafe.class.getDeclaredField("theUnsafe");
f.setAccessible(true);
unsafe = (Unsafe) f.get(null);

使用Unsafe实例化一个类

假设我们有一个简单的类，它的构造函数在创建对象时设置一个变量值

class TestUnsafe {
    private long value;
 
    public TestUnsafe () {
        this.value = 1;
    }
 
    public long getValue() {
        return this.value;
    }
}

当我们使用构造函数初始化该对象时，getValue()方法将返回一个值1:

TestUnsafe test = new TestUnsafe();
System.out.println(test .getValue())

但是我们可以使用Unsafe的allocateInstance()方法。它只会为我们的类分配内存，不会调用构造函数

TestUnsafe test1 
  = (TestUnsafe) unsafe.allocateInstance(TestUnsafe.class);
 
System.out.println(test.getValue())

这里实例化并没有调用构造函数，因此getA()方法返回long类型的默认值0

改变private字段值

如上的TestUnsafe类，它有一个私有属性value，并且没有set方法:

使用Unsafe 的putInt()方法，我们可以改变私有的value字段的值:

TestUnsafe  testUnsafe= new TestUnsafe();
 
Field f = testUnsafe.getClass().getDeclaredField("value");
unsafe.putInt(testUnsafe, unsafe.objectFieldOffset(f), 99);
 
System.out.println(test.getValue())

一旦我们通过反射调用得到一个字段，我们可以使用Unsafe的方法将其值更改为任何其他int值。

抛出一个异常

编译器不会像检查常规Java代码那样检查通过Unsafe调用的代码。我们可以使用throwException()方法抛出任何异常，而不限制调用方处理该异常，即使它是一个检查异常:

@Test(expected = IOException.class)
public void givenUnsafeThrowException_whenThrowCheckedException_thenNotNeedToCatchIt() {
    unsafe.throwException(new IOException());
}

在抛出一个检查过的IOException之后，我们不需要捕捉它，也不需要在方法声明中指定它

堆外内存

如果应用程序耗尽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()方法获取存储在数组中的索引和将给定value值存储在数组中。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.concurrent包中非常有效的设计，像AtomicInteger一样，都是使用Unsafe底层的compareAndSwap()方法，以提供可能的最佳性能。与Java中标准的悲观同步机制相比，这种构造在无锁算法中得到了广泛应用，这些算法可以利用CAS处理器机制来提供极大的加速。（实测使用compareAndSwap的自增比用synchronize的自增速度快2-3倍）

我们可以使用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，以便对所有正在写入和读取该值的线程都可见。我们使用objectFieldOffset()方法来获取offset 字段的内存地址。

该类中最重要的部分是increment()方法。我们在while循环中使用compareAndSwapLong()来增加之前获取的值，检查之前的值在我们获取之后是否发生了变化。

如果有，我们就会重新尝试，直到成功。这里没有阻塞，这就是为什么它被称为无锁算法。
我们可以通过从多个线程递增共享计数器来测试我们的代码:

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可以通过使用不安全类中的park()方法阻塞这个线程。

它非常类似于Object.wait()方法，但是它调用本机操作系统代码，从而利用一些架构细节来获得最佳性能

当线程被阻塞并需要再次使其可运行时，JVM使用unpark()方法。我们经常会在线程转储中看到这些方法调用，特别是在使用线程池的应用程序中。

参考文章：

1、https://www.baeldung.com/java-unsafe
2、https://blogs.oracle.com/javamagazine/the-unsafe-class-unsafe-at-any-speed#anchor_6

Sunday1105

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
详解java中的Unsafe

概述本文是学习笔记，主要是对baeldung和oracle官文的学习试验总结和翻译记录Unsafe，提供了主要为核心库内部使用而设计的底层机制。Java 8的 Unsafe类，位于sun.misc.Unsafe包，sun.misc包是一个内部包，实现特殊场景，一般java代码是不能直接接触到的，在Java 9 和往后的版本，包更加清晰的声明，Unsafe被移到了jdk.unsupported的包下。有时，我们可能需要打破既定的规则。在Java平台中，这通常通过使用三种主要机制之一来完成:反射、类加
复制链接

扫一扫