解密 Java 的不安全类：开发人员的秘密卷轴

# Web 开发 # Java

Java 的“Unsafe”类是低级编程能力的潘多拉魔盒。它违反了 Java 精心构建的安全措施，让您像巫师一样操纵内存、对象和并发。在本综合指南中，我们将介绍它的起源、功能、如何在 Java 版本中使用它以及更安全的替代方案，同时保持幽默和技术深度之间的平衡。

让我们踏上解开 Unsafe 秘密的旅程，并了解为什么它对开发人员来说既是福音又是祸害。

**第 1 章：Unsafe 简介 – 禁门**

想象一下 Java 是一位过度保护的父母。它确保你不会触碰炉子（原始内存）、不刷牙（构造函数）或违反规则（类型安全）。虽然这可以保证你的代码安全且易于维护，但有时会阻碍高级优化或低级操作。

输入 `Unsafe`**，这是 JVM 中的一个私有后门，可让您绕过这些限制。Unsafe 允许您：

直接访问和操作内存。

无需锁即可执行原子操作。

无需调用构造函数即可创建对象。

在 JVM 堆之外分配内存。

不安全并不适合胆小者。误用可能会导致 JVM 崩溃、内存损坏或引入安全漏洞。

**第 2 章：Unsafe 存在的原因**

Unsafe 不是为日常开发人员创建的。它是为 JDK 本身设计的，用于实现性能关键型功能。例如：

并发编程：java.util.concurrent 等工具使用 Unsafe 来实现无锁数据结构。

堆外内存：有效管理 JVM 堆外的大型数据集。

序列化：创建没有构造函数的对象以便快速反序列化它们。

自定义库：Unsafe 为 Netty、Hazelcast 和 Cassandra 等框架提供支持，以优化网络和数据库操作。

Unsafe 带来了一些在 Java 通常的限制内无法实现的可能性。

**第 3 章：访问 Unsafe – Java 9 之前和之后** Java 9 引入了 **Java 平台模块系统 (JPMS)** ，限制了对 Unsafe 等内部 API 的访问。让我们探索如何在两个时代访问 Unsafe。

**Java 9 之前访问 Unsafe**

在 Java 9 之前，访问 Unsafe 很简单——反射就是神奇的钥匙。

**代码示例（Java 9 之前）**

import sun.misc.Unsafe;

import java.lang.reflect.Field;

public class UnsafePreJava9 {
    public static void main(String[] args) throws Exception {
        Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
        unsafeField.setAccessible(true);
        Unsafe unsafe = (Unsafe) unsafeField.get(null);

        System.out.println("Unsafe instance: " + unsafe);
    }
}

**Java 9 之后访问 Unsafe** 使用 JPMS，对 `sun.misc.Unsafe` 等内部 API 的直接访问受到限制。Unsafe 已重新定位到 `jdk.internal.misc`**，需要显式模块访问。**在 Java 9+ 中访问 Unsafe 的步骤**

添加 JVM 参数：

--add-opens java.base/jdk.internal.misc=ALL-UNNAMED

使用反射访问 Unsafe。代码示例（Java 9 之后）

import jdk.internal.misc.Unsafe;

import java.lang.reflect.Field;

public class UnsafePostJava9 {
    public static Unsafe getUnsafe() throws Exception {
        Field theUnsafeField = Unsafe.class.getDeclaredField("theUnsafe");
        theUnsafeField.setAccessible(true);
        return (Unsafe) theUnsafeField.get(null);
    }

    public static void main(String[] args) throws Exception {
        Unsafe unsafe = getUnsafe();
        System.out.println("Unsafe instance (Java 9+): " + unsafe);
    }
}

**第 4 章：不安全的力量**

Unsafe 提供了一系列超越 Java 常见限制的功能。让我们通过代码示例深入探究这些功能。

**1. 记忆操纵**

Unsafe 允许您分配、访问和释放 JVM 堆之外的内存。这对于数据库等高性能应用程序非常有用。

**代码示例：分配内存**

public class MemoryExample {
    public static void main(String[] args) throws Exception {
        Unsafe unsafe = UnsafePostJava9.getUnsafe();

        // Allocate 10 bytes of memory
        long memoryAddress = unsafe.allocateMemory(10);
        System.out.println("Memory allocated at: " + memoryAddress);

        // Write to memory
        unsafe.putByte(memoryAddress, (byte) 42);
        byte value = unsafe.getByte(memoryAddress);
        System.out.println("Value at memory: " + value);

        // Free memory
        unsafe.freeMemory(memoryAddress);
        System.out.println("Memory freed.");
    }
}

**2. 具有不安全的堆外缓冲区** **堆外缓冲区**允许管理 JVM 堆外的数据，从而避免垃圾收集开销。**代码示例：堆外缓冲区**

import java.nio.ByteBuffer;

public class OffHeapBufferExample {
    public static void main(String[] args) {
        // Allocate off-heap buffer
        ByteBuffer buffer = ByteBuffer.allocateDirect(1024);

        // Write data
        buffer.putInt(42);

        // Read data
        buffer.flip();
        int value = buffer.getInt();

        System.out.println("Value from buffer: " + value);
    }
}

**3. 原子操作**

Unsafe 支持原子比较和交换 (CAS)，从而实现无锁算法。

**代码示例：CAS**

public class AtomicExample {
    static class Counter {
        volatile int value;
    }

    public static void main(String[] args) throws Exception {
        Unsafe unsafe = UnsafePostJava9.getUnsafe();
        Counter counter = new Counter();

        long offset = unsafe.objectFieldOffset(Counter.class.getDeclaredField("value"));

        // Perform CAS operation
        boolean success = unsafe.compareAndSwapInt(counter, offset, 0, 1);
        System.out.println("CAS success: " + success);
        System.out.println("Updated value: " + counter.value);
    }
}

**4. 绕过构造函数**

使用 Unsafe，您可以实例化对象而无需调用构造函数。这是一个强大但危险的功能，经常用于序列化框架。

**代码示例：构造函数绕过**

class Demo {
    private Demo() {
        throw new UnsupportedOperationException("Constructor not allowed");
    }
}

public class ConstructorBypassExample {
    public static void main(String[] args) throws Exception {
        Unsafe unsafe = UnsafePostJava9.getUnsafe();
        Demo demoInstance = (Demo) unsafe.allocateInstance(Demo.class);

        System.out.println("Demo instance created: " + demoInstance);
    }
}

**解释：**

这里，Unsafe 绕过了私有构造函数，允许在不调用其逻辑的情况下创建对象。这对于反序列化框架很有用。

**第 5 章：更安全的替代方案**

Unsafe 的强大之处也伴随着风险。Java 现在提供了更安全的替代方案来解决其常见用例：

VarHandle：Java 9 中引入，用于原子操作。

ByteBuffer：简化堆外内存管理。

虚引用：用于自定义内存管理。代码示例：VarHandle

import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;

public class VarHandleExample {
    static class Data {
        volatile int value;
    }

    public static void main(String[] args) throws Exception {
        Data data = new Data();
        VarHandle varHandle = MethodHandles.lookup().findVarHandle(Data.class, "value", int.class);

        // Atomic compare and set
        boolean success = varHandle.compareAndSet(data, 0, 1);
        System.out.println("CAS success: " + success);
        System.out.println("Updated value: " + data.value);
    }
}

**第 6 章：真实用例**

不安全的关键库权力：

数据库：Cassandra 使用 Unsafe 进行自定义内存管理。

网络：Netty 利用它优化 I/O 操作。

并发：在 java.util.concurrent 中用于非阻塞数据结构。

**第 7 章：结论** Unsafe 是 Java 的瑞士军刀，它提供了原始的力量，但需要谨慎使用。虽然存在诸如 **VarHandle** 和 **ByteBuffer** 等更安全的替代方案，但 Unsafe 对于小众高性能应用程序来说仍然是不可替代的。负责任地使用它，你就能释放 Java 的隐藏潜力。

CLIS.CC

解密 Java 的不安全类：开发人员的秘密卷轴