Unsafe

📚 Java Unsafe 类深度解析

🌟 Unsafe 类概述

sun.misc.Unsafe 是 Java 中的一个内部工具类，提供了一系列底层操作能力，直接操作内存、线程、对象和 CAS 等。由于它绕过了 JVM 的安全检查机制，使用时需谨慎，不当操作可能导致 JVM 崩溃或数据损坏。

核心特点：

直接内存操作：分配/释放堆外内存
原子性操作：CAS（Compare and Swap）
线程调度：挂起与唤醒线程
对象操作：绕过构造函数实例化对象
内存屏障：控制指令重排序
数组操作：高效访问数组元素

🧩 获取 Unsafe 实例

由于 Unsafe 被设计为单例且限制访问，必须通过反射获取：

public class UnsafeAccessor {
    private static final Unsafe unsafe;

    static {
        try {
            Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
            theUnsafe.setAccessible(true);
            unsafe = (Unsafe) theUnsafe.get(null);
        } catch (Exception e) {
            throw new Error(e);
        }
    }

    public static Unsafe getUnsafe() {
        return unsafe;
    }
}

⚙️ 核心功能详解

1. 内存管理

// 分配 1KB 堆外内存
long address = unsafe.allocateMemory(1024);

// 初始化内存为0
unsafe.setMemory(address, 1024, (byte) 0);

// 写入数据
unsafe.putInt(address, 123);       // 写入 int
unsafe.putLong(address + 4, 456L); // 偏移4字节写入 long

// 读取数据
int intVal = unsafe.getInt(address);       // 123
long longVal = unsafe.getLong(address + 4); // 456

// 释放内存
unsafe.freeMemory(address);

应用场景：

实现高性能 IO（如 Netty 的 ByteBuf）
自定义内存池

风险：内存泄漏、地址越界访问

2. CAS 原子操作

class AtomicCounter {
    private static final Unsafe unsafe = UnsafeAccessor.getUnsafe();
    private static final long valueOffset;
    private volatile int value;

    static {
        try {
            valueOffset = unsafe.objectFieldOffset(
                AtomicCounter.class.getDeclaredField("value"));
        } catch (NoSuchFieldException e) {
            throw new Error(e);
        }
    }

    public boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }
}

底层原理：

通过 CPU 指令（如 x86 的 LOCK CMPXCHG）实现原子性
JDK 原子类（如 AtomicInteger）的核心实现

3. 对象操作

// 绕过构造函数创建实例
MyClass obj = (MyClass) unsafe.allocateInstance(MyClass.class);

// 修改对象字段值
Field field = MyClass.class.getDeclaredField("value");
long fieldOffset = unsafe.objectFieldOffset(field);
unsafe.putInt(obj, fieldOffset, 100);

// 获取字段偏移地址
long staticFieldOffset = unsafe.staticFieldOffset(
    MyClass.class.getDeclaredField("STATIC_FIELD"));

应用场景：

序列化框架的高性能对象创建
动态修改对象状态

风险：破坏对象初始化逻辑

4. 线程调度

Thread thread = new Thread(() -> {
    System.out.println("Thread started");
    unsafe.park(false, 0); // 挂起线程
    System.out.println("Thread resumed");
});

thread.start();
Thread.sleep(1000);
unsafe.unpark(thread); // 唤醒线程

底层关联：LockSupport.park() / unpark() 的底层实现

5. 数组操作

int[] array = new int[10];
int base = unsafe.arrayBaseOffset(int[].class); // 获取数组首元素偏移地址
int scale = unsafe.arrayIndexScale(int[].class); // 获取元素间隔

// 直接修改 array[5]
unsafe.putInt(array, base + 5 * scale, 123);

性能优势：避免数组边界检查，提升访问速度

6. 内存屏障

// 禁止读操作重排序
unsafe.loadFence();

// 禁止写操作重排序
unsafe.storeFence();

// 完全内存屏障（读+写）
unsafe.fullFence();

应用场景：实现无锁数据结构（如 RingBuffer）

⚠️ 使用风险与限制

风险类型	具体表现	规避措施
JVM 崩溃	非法内存访问导致 SIGSEGV 错误	严格校验内存地址范围
内存泄漏	未正确释放分配的内存	使用 try-finally 确保释放
兼容性问题	JDK 版本升级导致 API 不可用	避免直接使用，优先标准库
破坏对象安全性	绕过构造函数导致对象状态不一致	仅用于明确知晓风险的场景
指令重排序问题	未正确使用内存屏障导致并发错误	深入理解内存模型

🌰 实战案例：实现简单锁

public class SimpleLock {
    private static final Unsafe unsafe = UnsafeAccessor.getUnsafe();
    private volatile int state;
    private static final long stateOffset;

    static {
        try {
            stateOffset = unsafe.objectFieldOffset(
                SimpleLock.class.getDeclaredField("state"));
        } catch (NoSuchFieldException e) {
            throw new Error(e);
        }
    }

    public void lock() {
        while (!unsafe.compareAndSwapInt(this, stateOffset, 0, 1)) {
            // 自旋或挂起线程
            unsafe.park(false, 0);
        }
    }

    public void unlock() {
        state = 0;
        unsafe.unpark(Thread.currentThread());
    }
}

📊 Unsafe 在 JDK 中的应用

JDK 类	Unsafe 用途
`AtomicInteger`	CAS 操作实现原子更新
`ConcurrentHashMap`	计算数组元素偏移地址
`LockSupport`	`park()` / `unpark()` 线程调度
`DirectByteBuffer`	分配堆外内存

💡 替代方案与最佳实践

优先使用标准库
- 并发控制 → java.util.concurrent 包
- 内存管理 → ByteBuffer / MemorySegment（Java 17）
限制使用场景
- 仅当标准库无法满足性能需求时使用
- 如实现高性能网络框架、数据库连接池等

代码防护

// 添加版本兼容性检查
if (JavaVersion.current().isNewerThan(JavaVersion.JAVA_11)) {
    throw new UnsupportedOperationException("Unsafe not supported");
}

总结：Unsafe 是 Java 生态中的一把双刃剑，它提供了突破 JVM 限制的能力，但也带来了极高的风险。理解其原理与适用场景，遵循「能用标准库则不用 Unsafe」的原则，才能在性能与安全之间找到平衡。