如何在Java中使用Unsafe类或者ByteBuffer实现直接内存访问？

在 Java 里，借助Unsafe类或者ByteBuffer能够实现直接内存访问，不过这种操作具有较高的风险性，可能会破坏内存安全，所以通常只在开发高性能组件或者系统底层库时才会使用。下面为你介绍这两种方式的具体实现：

1. 运用 Unsafe 类进行直接内存操作

Unsafe类可以绕过 Java 的安全检查机制，直接操作内存，但需要通过反射来获取实例：

java

import sun.misc.Unsafe;
import java.lang.reflect.Field;public class DirectMemoryAccess {private static Unsafe unsafe;static {try {// 通过反射获取Unsafe实例Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");theUnsafe.setAccessible(true);unsafe = (Unsafe) theUnsafe.get(null);} catch (Exception e) {throw new RuntimeException(e);}}public static void main(String[] args) {long size = 1024; // 分配1KB内存long address = unsafe.allocateMemory(size); // 分配内存try {// 写入数据unsafe.putByte(address, (byte) 65); // 写入'A'unsafe.putLong(address + 8, 123456789L); // 写入long值// 读取数据byte b = unsafe.getByte(address);long l = unsafe.getLong(address + 8);System.out.println("Byte: " + (char) b); // 输出: ASystem.out.println("Long: " + l);        // 输出: 123456789} finally {unsafe.freeMemory(address); // 释放内存}}
}

2. 使用 ByteBuffer 进行直接内存访问

ByteBuffer的allocateDirect()方法可以创建直接缓冲区，从而避免在 Java 堆和操作系统内存之间进行数据复制：

import java.nio.ByteBuffer;public class DirectByteBufferExample {public static void main(String[] args) {int capacity = 1024; // 1KB缓冲区ByteBuffer buffer = ByteBuffer.allocateDirect(capacity);// 写入数据buffer.put((byte) 65); // 写入'A'buffer.putLong(123456789L);// 切换到读模式buffer.flip();// 读取数据byte b = buffer.get();long l = buffer.getLong();System.out.println("Byte: " + (char) b); // 输出: ASystem.out.println("Long: " + l);        // 输出: 123456789// 释放直接缓冲区（由垃圾回收器处理，但可主动提示）((sun.nio.ch.DirectBuffer) buffer).cleaner().clean();}
}

注意要点

Unsafe 类的风险
- 必须手动管理内存，若忘记调用freeMemory()，会造成内存泄漏。
- 可能引发 JVM 崩溃，例如访问越界内存。
- 该类并非 Java 标准 API 的一部分，在不同版本的 JDK 中可能存在差异。
ByteBuffer 的优势
- 实现了自动内存管理，垃圾回收时会释放直接缓冲区。
- 提供了类型安全的访问方法，如putLong()、getInt()。
- 适用于 I/O 操作，能减少数据在用户空间和内核空间之间的复制。
适用场景
- Unsafe：适用于开发需要极致性能的底层库，像内存池、序列化框架等。
- ByteBuffer：适用于高性能 I/O 操作，例如网络编程、文件处理等。

安全提示

直接内存访问可能会破坏 Java 的安全机制，所以要谨慎使用。
在生产环境中，建议优先考虑使用标准 API，比如ByteArrayOutputStream或者FileChannel。
进行直接内存操作时，要确保进行边界检查，防止出现内存越界的情况。

除了Unsafe类，还有哪些方式可以实现Java的直接内存访问？

在 Java 中实现直接内存访问除了使用Unsafe类，还可以通过以下几种方式：

1. ByteBuffer.allocateDirect()

简介：通过 NIO 的ByteBuffer创建直接缓冲区，内存分配在堆外，减少 GC 压力，适合高性能 I/O 操作。

示例：

import java.nio.ByteBuffer;public class DirectByteBufferExample {public static void main(String[] args) {// 分配1MB直接内存ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 1024);buffer.putInt(0, 12345); // 写入整数int value = buffer.getInt(0); // 读取整数System.out.println("Value: " + value);// 手动释放（可选，GC会自动回收）((sun.nio.ch.DirectBuffer) buffer).cleaner().clean();}
}

优势：

避免 Java 堆与本地内存之间的数据复制。
由 JVM 管理内存释放，减少内存泄漏风险。

限制：
- 适用于连续内存块操作，不支持任意地址访问。
- 需要通过Cleaner机制手动释放（或等待 GC）。

2. JNA（Java Native Access）

简介：通过 JNA 可以直接调用本地库（如 C/C++）的函数，实现对内存的直接操作。

依赖：添加 Maven 依赖：xml

<dependency><groupId>net.java.dev.jna</groupId><artifactId>jna</artifactId><version>5.13.0</version>
</dependency>

示例：调用 C 标准库函数malloc和free：java

import com.sun.jna.Library;
import com.sun.jna.Native;
import com.sun.jna.Pointer;public class JNAMemoryAccess {public interface CLibrary extends Library {CLibrary INSTANCE = Native.load("c", CLibrary.class);Pointer malloc(int size);void free(Pointer p);void memset(Pointer p, int value, int size);}public static void main(String[] args) {Pointer p = CLibrary.INSTANCE.malloc(1024);try {CLibrary.INSTANCE.memset(p, 65, 10); // 写入'A'byte[] bytes = p.getByteArray(0, 10);System.out.println(new String(bytes)); // 输出: AAAAAAAAAA} finally {CLibrary.INSTANCE.free(p); // 手动释放内存}}
}

优势：
- 无需编写 JNI 代码，直接调用本地方法。
- 支持复杂数据结构和指针操作。
限制：
- 需要依赖本地库，跨平台兼容性较差。
- 需手动管理内存，可能引发泄漏。

3. JNI（Java Native Interface）

简介：通过 JNI 编写 C/C++ 代码实现底层内存操作，再由 Java 调用。

步骤：

定义 Java 本地方法：

public class JNIMemoryAccess {static {System.loadLibrary("native-lib"); // 加载本地库}public native long allocate(int size);public native void setByte(long address, byte value);public native byte getByte(long address);public native void free(long address);
}

编写 C/C++ 实现：

#include <jni.h>
JNIEXPORT jlong JNICALL Java_com_example_JNIMemoryAccess_allocate(JNIEnv* env, jobject obj, jint size) {return (jlong) malloc(size);
}
// 其他方法实现...

编译为动态库（.so/.dll）并加载。

优势：
- 完全控制底层内存，性能极高。
- 可调用任意 C/C++ 库。
限制：
- 开发复杂度高，需要掌握多语言。
- 调试困难，可能导致 JVM 崩溃。

4. sun.misc.SharedSecrets

简介：通过SharedSecrets访问内部类Unsafe，与直接使用Unsafe类似，但更隐蔽：

import sun.misc.SharedSecrets;
import sun.misc.Unsafe;public class SharedSecretsExample {public static void main(String[] args) {Unsafe unsafe = SharedSecrets.getJavaLangAccess().unsafe();long address = unsafe.allocateMemory(1024);unsafe.putByte(address, (byte) 65);// ... 其他操作unsafe.freeMemory(address);}
}

注意：这是 JDK 内部 API，不保证兼容性，可能在未来版本中移除。

5. MemorySegment (JDK 14+)

简介：Java 14 引入的java.lang.foreign模块提供更安全的内存访问 API：

import jdk.incubator.foreign.MemorySegment;
import jdk.incubator.foreign.ResourceScope;public class MemorySegmentExample {public static void main(String[] args) {try (ResourceScope scope = ResourceScope.newConfinedScope()) {// 分配1KB内存MemorySegment segment = MemorySegment.allocateNative(1024, scope);segment.setAtIndex(ValueLayout.JAVA_BYTE, 0, (byte) 65);byte value = segment.getAtIndex(ValueLayout.JAVA_BYTE, 0);System.out.println((char) value); // 输出: A} // 作用域结束时自动释放内存}
}

优势：
- 基于结构化内存模型，安全性更高。
- 自动资源管理（ARM），减少内存泄漏风险。
限制：
- 属于孵化 API，可能随 JDK 版本变化。
- 需要启用--add-modules java.foreign参数。

6. 第三方库：Netty 的 DirectByteBuf

简介：Netty 框架封装的直接内存操作工具，提供更友好的 API：

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;public class NettyDirectMemoryExample {public static void main(String[] args) {ByteBuf buffer = Unpooled.directBuffer(1024);try {buffer.writeByte(65);System.out.println((char) buffer.readByte()); // 输出: A} finally {buffer.release(); // 释放内存}}
}

优势：
- 池化管理直接内存，减少分配开销。
- 自动内存泄漏检测。

总结对比

方式	安全性	性能	跨平台	适用场景
ByteBuffer	高	中高	是	I/O 操作、数据传输
JNA	中（需手动管理）	高	部分	简单本地库调用
JNI	低（易崩溃）	极高	否	复杂 C/C++ 交互
MemorySegment	高	高	是	JDK 14+ 结构化内存操作
Netty	高	高	是	网络编程、高性能场景