深入理解java中Unsafe类及其实现原理

深入理解 Unsafe 类及其实现原理

一、简介

Unsafe 类是 Java 中一个关键但不公开的类，位于 sun.misc 包下。它提供了一系列底层操作，用于直接操作内存、执行原子操作和其他低级别任务。尽管 Unsafe 类非常强大，但由于其操作的危险性，Java 官方并不推荐直接使用它，并且该类仅对 JVM 内部和一些核心库开放。

二、Unsafe 类的作用

Unsafe 类主要提供以下几类功能：

• 内存操作：分配和释放内存、读写内存。
• 对象操作：读写对象的字段、操作对象头。
• CAS 操作：实现原子操作。
• 线程操作：挂起和恢复线程、执行内存屏障。
• 数组操作：操作数组元素、获取数组的基本信息。

三、Unsafe 类的实现原理

1. 内存操作

Unsafe 类可以直接在堆外分配内存，并提供对内存地址的直接访问方法。

public native long allocateMemory(long bytes);
public native void freeMemory(long address);
public native void putLong(long address, long x);
public native long getLong(long address);

• allocateMemory：分配指定大小的内存，返回内存地址。
• freeMemory：释放指定地址的内存。
• putLong/getLong：向指定内存地址写入/读取一个 long 类型的值。

2. 对象操作

Unsafe 类可以直接操作对象的字段，绕过 Java 的访问控制检查。

public native long objectFieldOffset(Field field);
public native Object getObject(Object o, long offset);
public native void putObject(Object o, long offset, Object x);

• objectFieldOffset：获取对象字段的内存偏移量。
• getObject/putObject：根据对象和偏移量读写对象的字段。

3. CAS 操作

Unsafe 类提供了一些 CAS 方法，用于实现无锁并发。

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

• compareAndSwapInt：比较并交换整数值。
• compareAndSwapLong：比较并交换长整数值。
• compareAndSwapObject：比较并交换对象引用。

这些方法通过硬件指令（如 x86 架构的 CMPXCHG）实现原子性操作。
想get更多，点这里：深入了解CAS原理

4. 线程操作

Unsafe 类可以直接操作线程，挂起和恢复线程。

public native void park(boolean isAbsolute, long time);
public native void unpark(Object thread);

• park：挂起线程。
• unpark：恢复线程。

5. 数组操作

Unsafe 类可以直接操作数组元素，获取数组的基本信息。

public native int arrayBaseOffset(Class<?> arrayClass);
public native int arrayIndexScale(Class<?> arrayClass);

• arrayBaseOffset：获取数组第一个元素的内存偏移量。
• arrayIndexScale：获取数组元素的增量大小。

四、使用示例

下面是一个简单的使用 Unsafe 类进行内存操作和 CAS 操作的示例：

import sun.misc.Unsafe;
import java.lang.reflect.Field;

public class UnsafeExample {
    private static final Unsafe unsafe;
    private static final long valueOffset;

    private volatile long value = 0;

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

    public void putValue(long newValue) {
        unsafe.putLong(this, valueOffset, newValue);
    }

    public long getValue() {
        return unsafe.getLong(this, valueOffset);
    }

    public boolean compareAndSetValue(long expected, long newValue) {
        return unsafe.compareAndSwapLong(this, valueOffset, expected, newValue);
    }

    public static void main(String[] args) {
        UnsafeExample example = new UnsafeExample();
        example.putValue(100);
        System.out.println("Initial value: " + example.getValue());

        boolean success = example.compareAndSetValue(100, 200);
        System.out.println("CAS success: " + success);
        System.out.println("Updated value: " + example.getValue());
    }
}

五、Unsafe 类的安全性和局限性

• 安全性：Unsafe 类提供的操作绕过了 Java 的安全检查，允许直接操作内存和对象，可能导致内存泄漏、数据损坏和系统崩溃。
• 跨平台性：Unsafe 类的实现依赖于特定平台的硬件和操作系统，因此不同平台上的行为可能不同。
• 维护性：使用 Unsafe 类编写的代码难以维护和调试，建议仅在性能要求极高的场景中使用。

六、总结

Unsafe 类通过提供底层的内存操作和原子操作，允许开发者在高性能场景中绕过 Java 的一些限制，实现更高效的代码。然而，由于其操作的危险性和不安全性，必须谨慎使用。理解 Unsafe 类的实现原理，有助于深入理解 Java 并发和 JVM 的底层机制。