Unsafe魔法类深度解析：Java底层操作的终极指南

介绍

Unsafe是位于sun.misc包下的一个类，主要提供一些用于执行低级别、不安全操作的方法，如直接访问系统内存资源、自主管理内存资源等，这些方法在提升Java运行效率、增强Java语言底层资源操作能力方面起到了很大的作用。但由于Unsafe类使Java语言拥有了类似C语言指针一样操作内存空间的能力，这无疑也增加了程序发生相关指针问题的风险。在程序中过度、不正确使用Unsafe类会使得程序出错的概率变大，使得Java这种安全的语言变得不再“安全”，因此对Unsafe的使用一定要慎重。
这个类尽管里面的方法都是 public 的，但是并没有办法使用它们，JDK API 文档也没有提供任何关于这个类的方法的解释。总而言之，对于 Unsafe 类的使用都是受限制的，只有授信的代码才能获得该类的实例，当然 JDK 库里面的类是可以随意使用的。
先来看下这张图，对UnSafe类总体功能：

如上图所示，Unsafe提供的API大致可分为内存操作、CAS、Class相关、对象操作、线程调度、系统信息获取、内存屏障、数组操作等几类，下面将对其相关方法和应用场景进行详细介绍。
内存操作

介绍

如果你是一个写过 C 或者 C++ 的程序员，一定对内存操作不会陌生，而在 Java 中是不允许直接对内存进行操作的，对象内存的分配和回收都是由 JVM 自己实现的。但是在 Unsafe 中，提供的下列接口可以直接进行内存操作：

1. //分配新的本地空间
2. public native long allocateMemory(long bytes);
3. //重新调整内存空间的大小
4. public native long reallocateMemory(long address, long bytes);
5. //将内存设置为指定值
6. public native void setMemory(Object o, long offset, long bytes, byte value);
7. //内存拷贝
8. public native void copyMemory(Object srcBase, long srcOffset,Object destBase, long destOffset,long bytes);
9. //清除内存
10. public native void freeMemory(long address);

复制代码

使用下面的代码进行测试：

1. private void memoryTest() {
2.     int size = 4;
3.     long addr = unsafe.allocateMemory(size);
4.     long addr3 = unsafe.reallocateMemory(addr, size * 2);
5.     System.out.println("addr: "+addr);
6.     System.out.println("addr3: "+addr3);
7.     try {
8.         unsafe.setMemory(null,addr ,size,(byte)1);
9.         for (int i = 0; i < 2; i++) {
10.             unsafe.copyMemory(null,addr,null,addr3+size*i,4);
11.         }
12.         System.out.println(unsafe.getInt(addr));
13.         System.out.println(unsafe.getLong(addr3));
14.     }finally {
15.         unsafe.freeMemory(addr);
16.         unsafe.freeMemory(addr3);
17.     }
18. }

复制代码

先看结果输出：

1. addr: 2433733895744
2. addr3: 2433733894944
3. 16843009
4. 72340172838076673

复制代码

分析一下运行结果，首先使用allocateMemory方法申请 4 字节长度的内存空间，调用setMemory方法向每个字节写入内容为byte类型的 1，当使用 Unsafe 调用getInt方法时，因为一个int型变量占 4 个字节，会一次性读取 4 个字节，组成一个int的值，对应的十进制结果为 16843009。
你可以通过下图理解这个过程：

在代码中调用reallocateMemory方法重新分配了一块 8 字节长度的内存空间，通过比较addr和addr3可以看到和之前申请的内存地址是不同的。在代码中的第二个 for 循环里，调用copyMemory方法进行了两次内存的拷贝，每次拷贝内存地址addr开始的 4 个字节，分别拷贝到以addr3和addr3+4开始的内存空间上：

拷贝完成后，使用getLong方法一次性读取 8 个字节，得到long类型的值为 72340172838076673。
需要注意，通过这种方式分配的内存属于 堆外内存 ，是无法进行垃圾回收的，需要我们把这些内存当做一种资源去手动调用freeMemory方法进行释放，否则会产生内存泄漏。通用的操作内存方式是在try中执行对内存的操作，最终在finally块中进行内存的释放。
为什么要使用堆外内存？

• 对垃圾回收停顿的改善。由于堆外内存是直接受操作系统管理而不是 JVM，所以当我们使用堆外内存时，即可保持较小的堆内内存规模。从而在 GC 时减少回收停顿对于应用的影响。
  
• 提升程序 I/O 操作的性能。通常在 I/O 通信过程中，会存在堆内内存到堆外内存的数据拷贝操作，对于需要频繁进行内存间数据拷贝且生命周期较短的暂存数据，都建议存储到堆外内存。
  

典型应用

DirectByteBuffer 是 Java 用于实现堆外内存的一个重要类，通常用在通信过程中做缓冲池，如在 Netty、MINA 等 NIO 框架中应用广泛。DirectByteBuffer 对于堆外内存的创建、使用、销毁等逻辑均由 Unsafe 提供的堆外内存 API 来实现。
下图为 DirectByteBuffer 构造函数，创建 DirectByteBuffer 的时候，通过 Unsafe.allocateMemory 分配内存、Unsafe.setMemory 进行内存初始化，而后构建 Cleaner 对象用于跟踪 DirectByteBuffer 对象的垃圾回收，以实现当 DirectByteBuffer 被垃圾回收时，分配的堆外内存一起被释放。

1. DirectByteBuffer(int cap) {                   // package-private
3.     super(-1, 0, cap, cap);
4.     boolean pa = VM.isDirectMemoryPageAligned();
5.     int ps = Bits.pageSize();
6.     long size = Math.max(1L, (long)cap + (pa ? ps : 0));
7.     Bits.reserveMemory(size, cap);
9.     long base = 0;
10.     try {
11.         // 分配内存并返回基地址
12.         base = unsafe.allocateMemory(size);
13.     } catch (OutOfMemoryError x) {
14.         Bits.unreserveMemory(size, cap);
15.         throw x;
16.     }
17.     // 内存初始化
18.     unsafe.setMemory(base, size, (byte) 0);
19.     if (pa && (base % ps != 0)) {
20.         // Round up to page boundary
21.         address = base + ps - (base & (ps - 1));
22.     } else {
23.         address = base;
24.     }
25.     // 跟踪 DirectByteBuffer 对象的垃圾回收，以实现堆外内存释放
26.     cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
27.     att = null;
28. }

复制代码

内存屏障

介绍

在介绍内存屏障前，需要知道编译器和 CPU 会在保证程序输出结果一致的情况下，会对代码进行重排序，从指令优化角度提升性能。而指令重排序可能会带来一个不好的结果，导致 CPU 的高速缓存和内存中数据的不一致，而内存屏障（Memory Barrier）就是通过阻止屏障两边的指令重排序从而避免编译器和硬件的不正确优化情况。
在硬件层面上，内存屏障是 CPU 为了防止代码进行重排序而提供的指令，不同的硬件平台上实现内存屏障的方法可能并不相同。在 Java8 中，引入了 3 个内存屏障的函数，它屏蔽了操作系统底层的差异，允许在代码中定义、并统一由 JVM 来生成内存屏障指令，来实现内存屏障的功能。
Unsafe 中提供了下面三个内存屏障相关方法：

1. //内存屏障，禁止load操作重排序。屏障前的load操作不能被重排序到屏障后，屏障后的load操作不能被重排序到屏障前
2. public native void loadFence();
3. //内存屏障，禁止store操作重排序。屏障前的store操作不能被重排序到屏障后，屏障后的store操作不能被重排序到屏障前
4. public native void storeFence();
5. //内存屏障，禁止load、store操作重排序
6. public native void fullFence();

复制代码

内存屏障可以看做对内存随机访问的操作中的一个同步点，使得此点之前的所有读写操作都执行后才可以开始执行此点之后的操作。以loadFence方法为例，它会禁止读操作重排序，保证在这个屏障之前的所有读操作都已经完成，并且将缓存数据设为无效，重新从主存中进行加载。
看到这估计很多小伙伴们会想到volatile关键字了，如果在字段上添加了volatile关键字，就能够实现字段在多线程下的可见性。基于读内存屏障，我们也能实现相同的功能。下面定义一个线程方法，在线程中去修改flag标志位，注意这里的flag是没有被volatile修饰的：

1. @Getter
2. class ChangeThread implements Runnable{
3.     /**volatile**/ boolean flag=false;
4.     @Override
5.     public void run() {
6.         try {
7.             Thread.sleep(3000);
8.         } catch (InterruptedException e) {
9.             e.printStackTrace();
10.         }
11.         System.out.println("subThread change flag to:" + flag);
12.         flag = true;
13.     }
14. }

复制代码

在主线程的while循环中，加入内存屏障，测试是否能够感知到flag的修改变化：

1. public static void main(String[] args){
2.     ChangeThread changeThread = new ChangeThread();
3.     new Thread(changeThread).start();
4.     while (true) {
5.         boolean flag = changeThread.isFlag();
6.         unsafe.loadFence(); //加入读内存屏障
7.         if (flag){
8.             System.out.println("detected flag changed");
9.             break;
10.         }
11.     }
12.     System.out.println("main thread end");
13. }

复制代码

运行结果：

1. subThread change flag to:false
2. detected flag changed
3. main thread end

复制代码

而如果删掉上面代码中的loadFence方法，那么主线程将无法感知到flag发生的变化，会一直在while中循环。可以用图来表示上面的过程：

了解 Java 内存模型（JMM）的小伙伴们应该清楚，运行中的线程不是直接读取主内存中的变量的，只能操作自己工作内存中的变量，然后同步到主内存中，并且线程的工作内存是不能共享的。上面的图中的流程就是子线程借助于主内存，将修改后的结果同步给了主线程，进而修改主线程中的工作空间，跳出循环。
典型应用

在 Java 8 中引入了一种锁的新机制——StampedLock，它可以看成是读写锁的一个改进版本。StampedLock 提供了一种乐观读锁的实现，这种乐观读锁类似于无锁的操作，完全不会阻塞写线程获取写锁，从而缓解读多写少时写线程“饥饿”现象。由于 StampedLock 提供的乐观读锁不阻塞写线程获取读锁，当线程共享变量从主内存 load 到线程工作内存时，会存在数据不一致问题。
为了解决这个问题，StampedLock 的 validate 方法会通过 Unsafe 的 loadFence 方法加入一个 load 内存屏障。

1. public boolean validate(long stamp) {
2.    U.loadFence();
3.    return (stamp & SBITS) == (state & SBITS);
4. }

复制代码

对象操作

介绍

例子

1. import sun.misc.Unsafe;
2. import java.lang.reflect.Field;
4. public class Main {
6.     private int value;
8.     public static void main(String[] args) throws Exception{
9.         Unsafe unsafe = reflectGetUnsafe();
10.         assert unsafe != null;
11.         long offset = unsafe.objectFieldOffset(Main.class.getDeclaredField("value"));
12.         Main main = new Main();
13.         System.out.println("value before putInt: " + main.value);
14.         unsafe.putInt(main, offset, 42);
15.         System.out.println("value after putInt: " + main.value);
16.   System.out.println("value after putInt: " + unsafe.getInt(main, offset));
17.     }
19.     private static Unsafe reflectGetUnsafe() {
20.         try {
21.             Field field = Unsafe.class.getDeclaredField("theUnsafe");
22.             field.setAccessible(true);
23.             return (Unsafe) field.get(null);
24.         } catch (Exception e) {
25.             e.printStackTrace();
26.             return null;
27.         }
28.     }
30. }

复制代码

输出结果：

1. value before putInt: 0
2. value after putInt: 42
3. value after putInt: 42

复制代码

对象属性
对象成员属性的内存偏移量获取，以及字段属性值的修改，在上面的例子中我们已经测试过了。除了前面的putInt、getInt方法外，Unsafe 提供了全部 8 种基础数据类型以及Object的put和get方法，并且所有的put方法都可以越过访问权限，直接修改内存中的数据。阅读 openJDK 源码中的注释发现，基础数据类型和Object的读写稍有不同，基础数据类型是直接操作的属性值（value），而Object的操作则是基于引用值（reference value）。下面是Object的读写方法：

1. //在对象的指定偏移地址获取一个对象引用
2. public native Object getObject(Object o, long offset);
3. //在对象指定偏移地址写入一个对象引用
4. public native void putObject(Object o, long offset, Object x);

复制代码

除了对象属性的普通读写外，Unsafe 还提供了 volatile 读写和有序写入方法。volatile读写方法的覆盖范围与普通读写相同，包含了全部基础数据类型和Object类型，以int类型为例：

1. //在对象的指定偏移地址处读取一个int值，支持volatile load语义
2. public native int getIntVolatile(Object o, long offset);
3. //在对象指定偏移地址处写入一个int，支持volatile store语义
4. public native void putIntVolatile(Object o, long offset, int x);

复制代码

相对于普通读写来说，volatile读写具有更高的成本，因为它需要保证可见性和有序性。在执行get操作时，会强制从主存中获取属性值，在使用put方法设置属性值时，会强制将值更新到主存中，从而保证这些变更对其他线程是可见的。
有序写入的方法有以下三个：

1. public native void putOrderedObject(Object o, long offset, Object x);
2. public native void putOrderedInt(Object o, long offset, int x);
3. public native void putOrderedLong(Object o, long offset, long x);

复制代码

有序写入的成本相对volatile较低，因为它只保证写入时的有序性，而不保证可见性，也就是一个线程写入的值不能保证其他线程立即可见。为了解决这里的差异性，需要对内存屏障的知识点再进一步进行补充，首先需要了解两个指令的概念：

• Load：将主内存中的数据拷贝到处理器的缓存中
  
• Store：将处理器缓存的数据刷新到主内存中
  

顺序写入与volatile写入的差别在于，在顺序写时加入的内存屏障类型为StoreStore类型，而在volatile写入时加入的内存屏障是StoreLoad类型，如下图所示：

在有序写入方法中，使用的是StoreStore屏障，该屏障确保Store1立刻刷新数据到内存，这一操作先于Store2以及后续的存储指令操作。而在volatile写入中，使用的是StoreLoad屏障，该屏障确保Store1立刻刷新数据到内存，这一操作先于Load2及后续的装载指令，并且，StoreLoad屏障会使该屏障之前的所有内存访问指令，包括存储指令和访问指令全部完成之后，才执行该屏障之后的内存访问指令。
综上所述，在上面的三类写入方法中，在写入效率方面，按照put、putOrder、putVolatile的顺序效率逐渐降低。
对象实例化
使用 Unsafe 的 allocateInstance 方法，允许我们使用非常规的方式进行对象的实例化，首先定义一个实体类，并且在构造函数中对其成员变量进行赋值操作：

1. @Data
2. public class A {
3.     private int b;
4.     public A(){
5.         this.b =1;
6.     }
7. }

复制代码

分别基于构造函数、反射以及 Unsafe 方法的不同方式创建对象进行比较：

1. public void objTest() throws Exception{
2.     A a1=new A();
3.     System.out.println(a1.getB());
4.     A a2 = A.class.newInstance();
5.     System.out.println(a2.getB());
6.     A a3= (A) unsafe.allocateInstance(A.class);
7.     System.out.println(a3.getB());
8. }

复制代码

打印结果分别为 1、1、0，说明通过allocateInstance方法创建对象过程中，不会调用类的构造方法。使用这种方式创建对象时，只用到了Class对象，所以说如果想要跳过对象的初始化阶段或者跳过构造器的安全检查，就可以使用这种方法。在上面的例子中，如果将 A 类的构造函数改为private类型，将无法通过构造函数和反射创建对象（可以通过构造函数对象 setAccessible 后创建对象），但allocateInstance方法仍然有效。
典型应用

• 常规对象实例化方式：我们通常所用到的创建对象的方式，从本质上来讲，都是通过 new 机制来实现对象的创建。但是，new 机制有个特点就是当类只提供有参的构造函数且无显示声明无参构造函数时，则必须使用有参构造函数进行对象构造，而使用有参构造函数时，必须传递相应个数的参数才能完成对象实例化。
  
• 非常规的实例化方式：而 Unsafe 中提供 allocateInstance 方法，仅通过 Class 对象就可以创建此类的实例对象，而且不需要调用其构造函数、初始化代码、JVM 安全检查等。它抑制修饰符检测，也就是即使构造器是 private 修饰的也能通过此方法实例化，只需提类对象即可创建相应的对象。由于这种特性，allocateInstance 在 java.lang.invoke、Objenesis（提供绕过类构造器的对象生成方式）、Gson（反序列化时用到）中都有相应的应用。
  

数组操作

介绍

arrayBaseOffset 与 arrayIndexScale 这两个方法配合起来使用，即可定位数组中每个元素在内存中的位置。

1. //返回数组中第一个元素的偏移地址
2. public native int arrayBaseOffset(Class<?> arrayClass);
3. //返回数组中一个元素占用的大小
4. public native int arrayIndexScale(Class<?> arrayClass);

复制代码

典型应用

这两个与数据操作相关的方法，在 java.util.concurrent.atomic 包下的 AtomicIntegerArray（可以实现对 Integer 数组中每个元素的原子性操作）中有典型的应用，如下图 AtomicIntegerArray 源码所示，通过 Unsafe 的 arrayBaseOffset、arrayIndexScale 分别获取数组首元素的偏移地址 base 及单个元素大小因子 scale 。后续相关原子性操作，均依赖于这两个值进行数组中元素的定位，如下图二所示的 getAndAdd 方法即通过 checkedByteOffset 方法获取某数组元素的偏移地址，而后通过 CAS 实现原子性操作。

CAS 操作

介绍

这部分主要为 CAS 相关操作的方法。

1. /**
2.   *  CAS
3.   * @param o         包含要修改field的对象
4.   * @param offset    对象中某field的偏移量
5.   * @param expected  期望值
6.   * @param update    更新值
7.   * @return          true | false
8.   */
9. public final native boolean compareAndSwapObject(Object o, long offset,  Object expected, Object update);
11. public final native boolean compareAndSwapInt(Object o, long offset, int expected,int update);
13. public final native boolean compareAndSwapLong(Object o, long offset, long expected, long update);

复制代码

什么是 CAS? CAS 即比较并替换（Compare And Swap)，是实现并发算法时常用到的一种技术。CAS 操作包含三个操作数——内存位置、预期原值及新值。执行 CAS 操作的时候，将内存位置的值与预期原值比较，如果相匹配，那么处理器会自动将该位置值更新为新值，否则，处理器不做任何操作。我们都知道，CAS 是一条 CPU 的原子指令（cmpxchg 指令），不会造成所谓的数据不一致问题，Unsafe 提供的 CAS 方法（如 compareAndSwapXXX）底层实现即为 CPU 指令 cmpxchg 。
典型应用

在 JUC 包的并发工具类中大量地使用了 CAS 操作，像在前面介绍synchronized和AQS的文章中也多次提到了 CAS，其作为乐观锁在并发工具类中广泛发挥了作用。在 Unsafe 类中，提供了compareAndSwapObject、compareAndSwapInt、compareAndSwapLong方法来实现的对Object、int、long类型的 CAS 操作。以compareAndSwapInt方法为例：

1. public final native boolean compareAndSwapInt(Object o, long offset,int expected,int x);

复制代码

参数中o为需要更新的对象，offset是对象o中整形字段的偏移量，如果这个字段的值与expected相同，则将字段的值设为x这个新值，并且此更新是不可被中断的，也就是一个原子操作。下面是一个使用compareAndSwapInt的例子：

1. private volatile int a;
2. public static void main(String[] args){
3.     CasTest casTest=new CasTest();
4.     new Thread(()->{
5.         for (int i = 1; i < 5; i++) {
6.             casTest.increment(i);
7.             System.out.print(casTest.a+" ");
8.         }
9.     }).start();
10.     new Thread(()->{
11.         for (int i = 5 ; i <10 ; i++) {
12.             casTest.increment(i);
13.             System.out.print(casTest.a+" ");
14.         }
15.     }).start();
16. }
18. private void increment(int x){
19.     while (true){
20.         try {
21.             long fieldOffset = unsafe.objectFieldOffset(CasTest.class.getDeclaredField("a"));
22.             if (unsafe.compareAndSwapInt(this,fieldOffset,x-1,x))
23.                 break;
24.         } catch (NoSuchFieldException e) {
25.             e.printStackTrace();
26.         }
27.     }
28. }

复制代码

程序输出为：

1. 1 2 3 4 5 6 7 8 9

复制代码

程序运行的流程也比较容易看懂，子线程开始运行后先进行睡眠，确保主线程能够调用park方法阻塞自己，子线程在睡眠 5 秒后，调用unpark方法唤醒主线程，使主线程能继续向下执行。整个流程如下图所示：

Class 操作

介绍

Unsafe 对Class的相关操作主要包括类加载和静态变量的操作方法。
静态属性读取相关的方法

1. //取消阻塞线程
2. public native void unpark(Object thread);
3. //阻塞线程
4. public native void park(boolean isAbsolute, long time);
5. //获得对象锁（可重入锁）
6. @Deprecated
7. public native void monitorEnter(Object o);
8. //释放对象锁
9. @Deprecated
10. public native void monitorExit(Object o);
11. //尝试获取对象锁
12. @Deprecated
13. public native boolean tryMonitorEnter(Object o);

复制代码

创建一个包含静态属性的类，进行测试：

1. //获得对象锁
2. @Deprecated
3. public native void monitorEnter(Object var1);
4. //释放对象锁
5. @Deprecated
6. public native void monitorExit(Object var1);
7. //尝试获得对象锁
8. @Deprecated
9. public native boolean tryMonitorEnter(Object var1);

复制代码

运行结果：

1. public static void park(Object blocker) {
2.     Thread t = Thread.currentThread();
3.     setBlocker(t, blocker);
4.     UNSAFE.park(false, 0L);
5.     setBlocker(t, null);
6. }
7. public static void unpark(Thread thread) {
8.     if (thread != null)
9.         UNSAFE.unpark(thread);
10. }

复制代码

在 Unsafe 的对象操作中，我们学习了通过objectFieldOffset方法获取对象属性偏移量并基于它对变量的值进行存取，但是它不适用于类中的静态属性，这时候就需要使用staticFieldOffset方法。在上面的代码中，只有在获取Field对象的过程中依赖到了Class，而获取静态变量的属性时不再依赖于Class。
在上面的代码中首先创建一个User对象，这是因为如果一个类没有被初始化，那么它的静态属性也不会被初始化，最后获取的字段属性将是null。所以在获取静态属性前，需要调用shouldBeInitialized方法，判断在获取前是否需要初始化这个类。如果删除创建 User 对象的语句，运行结果会变为：

1. public static void main(String[] args) {
2.     Thread mainThread = Thread.currentThread();
3.     new Thread(()->{
4.         try {
5.             TimeUnit.SECONDS.sleep(5);
6.             System.out.println("subThread try to unpark mainThread");
7.             unsafe.unpark(mainThread);
8.         } catch (InterruptedException e) {
9.             e.printStackTrace();
10.         }
11.     }).start();
13.     System.out.println("park main mainThread");
14.     unsafe.park(false,0L);
15.     System.out.println("unpark mainThread success");
16. }

复制代码

使用defineClass方法允许程序在运行时动态地创建一个类

1. park main mainThread
2. subThread try to unpark mainThread
3. unpark mainThread success

复制代码

在实际使用过程中，可以只传入字节数组、起始字节的下标以及读取的字节长度，默认情况下，类加载器（ClassLoader）和保护域（ProtectionDomain）来源于调用此方法的实例。下面的例子中实现了反编译生成后的 class 文件的功能：

1. //获取静态属性的偏移量
2. public native long staticFieldOffset(Field f);
3. //获取静态属性的对象指针
4. public native Object staticFieldBase(Field f);
5. //判断类是否需要初始化（用于获取类的静态属性前进行检测）
6. public native boolean shouldBeInitialized(Class<?> c);

复制代码

在上面的代码中，首先读取了一个class文件并通过文件流将它转化为字节数组，之后使用defineClass方法动态的创建了一个类，并在后续完成了它的实例化工作，流程如下图所示，并且通过这种方式创建的类，会跳过 JVM 的所有安全检查。

除了defineClass方法外，Unsafe 还提供了一个defineAnonymousClass方法：

1. @Data
2. public class User {
3.     public static String name="Hydra";
4.     int age;
5. }
6. private void staticTest() throws Exception {
7.     User user=new User();
8.     // 也可以用下面的语句触发类初始化
9.     // 1.
10.     // unsafe.ensureClassInitialized(User.class);
11.     // 2.
12.     // System.out.println(User.name);
13.     System.out.println(unsafe.shouldBeInitialized(User.class));
14.     Field sexField = User.class.getDeclaredField("name");
15.     long fieldOffset = unsafe.staticFieldOffset(sexField);
16.     Object fieldBase = unsafe.staticFieldBase(sexField);
17.     Object object = unsafe.getObject(fieldBase, fieldOffset);
18.     System.out.println(object);
19. }

复制代码

使用该方法可以用来动态的创建一个匿名类，在Lambda表达式中就是使用 ASM 动态生成字节码，然后利用该方法定义实现相应的函数式接口的匿名类。在 JDK 15 发布的新特性中，在隐藏类（Hidden classes）一条中，指出将在未来的版本中弃用 Unsafe 的defineAnonymousClass方法。
典型应用

Lambda 表达式实现需要依赖 Unsafe 的 defineAnonymousClass 方法定义实现相应的函数式接口的匿名类。
系统信息

介绍

这部分包含两个获取系统相关信息的方法。

1. false
2. Hydra

复制代码

典型应用

这两个方法的应用场景比较少，在java.nio.Bits类中，在使用pageCount计算所需的内存页的数量时，调用了pageSize方法获取内存页的大小。另外，在使用copySwapMemory方法拷贝内存时，调用了addressSize方法，检测 32 位系统的情况。
Unsafe底层

再看看Unsafe的compareAndSwap 方法来实现CAS操作，它是一个本地方法，实现位于unsafe.cpp中。

1. true
2. null

复制代码

可以看到它通过 Atomic::cmpxchg 来实现比较和替换操作。其中参数x是即将更新的值，参数e是原内存的值。
如果是Linux的x86，Atomic::cmpxchg方法的实现如下：

1. public native Class<?> defineClass(String name, byte[] b, int off, int len, ClassLoader loader,ProtectionDomain protectionDomain);

复制代码

而windows的x86的实现如下：

1. private static void defineTest() {
2.     String fileName="F:\\workspace\\unsafe-test\\target\\classes\\com\\cn\\model\\User.class";
3.     File file = new File(fileName);
4.     try(FileInputStream fis = new FileInputStream(file)) {
5.         byte[] content=new byte[(int)file.length()];
6.         fis.read(content);
7.         Class clazz = unsafe.defineClass(null, content, 0, content.length, null, null);
8.         Object o = clazz.newInstance();
9.         Object age = clazz.getMethod("getAge").invoke(o, null);
10.         System.out.println(age);
11.     } catch (Exception e) {
12.         e.printStackTrace();
13.     }
14. }

复制代码

如果是多处理器，为cmpxchg指令添加lock前缀。反之，就省略lock前缀(单处理器会不需要lock前缀提供的内存屏障效果)。这里的lock前缀就是使用了处理器的总线锁(最新的处理器都使用缓存锁代替总线锁来提高性能)。

cmpxchg(void* ptr, int old, int new)，如果ptr和old的值一样，则把new写到ptr内存，否则返回ptr的值，整个操作是原子的。在Intel平台下，会用lock cmpxchg来实现，使用lock触发缓存锁，这样另一个线程想访问ptr的内存，就会被block住。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

不错，里面软件多更新就更好了

分享、互助 让互联网精神温暖你我

不错，里面软件多更新就更好了

谢谢分享，试用一下

鼓励转贴优秀软件安全工具和文档！

喜欢鼓捣这些软件，现在用得少，谢谢分享！

感谢分享

新版吗？好像是停更了吧。

很好很强大  我过来先占个楼 待编辑

谢谢分享，试用一下

前排留名，哈哈哈

鼓励转贴优秀软件安全工具和文档！

感谢分享，学习下。

过来提前占个楼