java 的 unsafe 类是低级编程能力的潘多拉魔盒。它违背了 java 精心构建的保护措施，让您可以像向导一样操作内存、对象和并发性。在这份综合指南中，我们将介绍它的起源、功能、如何跨 java 版本使用它以及更安全的替代方案，同时保持幽默和技术深度之间的平衡。
让我们踏上旅程，揭开 unsafe 的秘密，并了解为什么它对开发者来说既是福也是祸。
第一章：不安全简介 – 禁门
将 java 想象成一个过度保护的父母。它确保你不会碰炉子（原始内存）、跳过刷牙（构造函数）或违反规则（类型安全）。虽然这可以保证您的代码安全且可维护，但有时会阻碍高级优化或低级操作。
输入 unsafe** ，这是 jvm 中的一个私有后门，可以让您绕过这些限制。不安全允许您：
直接访问和操作内存。
无需锁即可执行原子操作。
创建对象而不调用构造函数。
-
在 jvm 堆之外分配内存。
立即学习“Java免费学习笔记（深入）”；
不安全不适合胆小的人。误用可能会使 jvm 崩溃、损坏内存或引入安全漏洞。
第二章：为什么存在不安全
unsafe 并不是为日常开发人员创建的。它是为 jdk 本身设计的，用于实现性能关键的功能。例如：
并发编程：像 java.util.concurrent 这样的工具使用不安全的无锁数据结构。
堆外内存：高效管理 jvm 堆外的大型数据集。
序列化： 创建不带构造函数的对象以快速反序列化它们。
自定义库：不安全的框架（如 netty、hazelcast 和 cassandra）可优化网络和数据库操作。
不安全带来了在 java 的通常限制下不可行的可能性。
对设计或页面进行 WCAG 2.1 AA 无障碍审计。触发关键词：“audit accessibility”、 “check a11y”、 “is this accessible?” 或在审查设计时使用。
第 3 章：访问 unsafe – java 9 之前和之后 java 9 引入了 java 平台模块系统 (jpms) ，限制对 unsafe 等内部 api 的访问。让我们探讨如何在这两个时代访问 unsafe。
java 9 之前访问不安全
在 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 章：结论 不安全是 java 的瑞士军刀，提供原始功能但需要谨慎。虽然存在 varhandle 和 bytebuffer 等更安全的替代方案，但对于小众高性能应用程序来说，unsafe 仍然是不可替代的。负责任地使用它，您就可以释放 java 隐藏的潜力。“强大的能力带来强大的调试。”
