1. 前言 本节对 Unsafe 类的使用进行讲解，上一小节内容已经对 Unsafe 类的常用方法有了大体的概括，本节主要内容点如下：Unsafe 类的简介，对 UnSafe 类有一个整体的认识；Unsafe 类的创建以及创建过程中避免的异常机制，这是开始使用 UnSafe 类的前提；了解 Unsafe 类操作对...
本节对 Unsafe 类的使用进行讲解，上一小节内容已经对 Unsafe 类的常用方法有了大体的概括，本节主要内容点如下：
Unsafe 类的简介，对 UnSafe 类有一个整体的认识；
Unsafe 类的创建以及创建过程中避免的异常机制，这是开始使用 UnSafe 类的前提；
了解 Unsafe 类操作对象属性方法的使用，这是本节内容的重点之一；
了解 Unsafe 操作数组元素方法的使用，也是本节内容的重点之一。
本节内容意在了解并掌握 Unsafe 类的常用方法的使用。
Unsafe 类是 J**a 整个并发包底层实现的核心，它具有像 C++ 的指针一样直接操作内存的能力，而这也就意味着其越过了 JVM 的限制。
Unsafe 类有如下的特点：
Unsafe 类是不可以通过 new 关键字直接创建的。Unsafe 类的构造函数是私有的，而对外提供的静态方法 Unsafe.getUnsafe () 又对调用者的 ClassLoader 有限制 ，如果这个方法的调用者不是由 Boot ClassLoader 加载的，则会报错。
实例：通过 main 方法进行调用，报错。
import sun.misc.Unsafe;
import sun.misc.VM;
import sun.reflect.Reflection;
public class DemoTest {
public static void main(String[] args) {
getUnsafe();
}
public static Unsafe getUnsafe() {
Class unsafeClass = Reflection.getCallerClass();
if (!VM.isSystemDomainLoader(unsafeClass.getClassLoader())) {
throw new SecurityException("Unsafe");
} else {
return null;
}
}
}
运行结果：
Exception in thread "main" j**a.lang.InternalError: CallerSensitive annotation expected at frame 1
at sun.reflect.Reflection.getCallerClass(Native Method)
at leeCode.DemoTest.getUnsafe(DemoTest.j**a:12)
at leeCode.DemoTest.main(DemoTest.j**a:9)
报错原因： J**a 源码中由开发者自定义的类都是由 Appliaction ClassLoader 加载的，也就是说 main 函数所依赖的 jar 包都是 ClassLoader 加载的，所以会报错。
所以正常情况下我们无法直接使用 Unsafe ，如果需要使用它，则需要利用反射
实例：通过反射，成功加载 Unsafe 类。
import sun.misc.Unsafe;
import j**a.lang.reflect.Field;
public class DemoTest {
public static void main(String[] args) {
Unsafe unsafe = getUnsafe();
System.out.println("Unsafe 加载成功："+unsafe);
}
public static Unsafe getUnsafe() {
Unsafe unsafe = null;
try {
Field field = Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
unsafe = (Unsafe) field.get(null);
} catch (Exception e) {
e.printStackTrace();
}
return unsafe;
}
}
结果验证：
Unsafe 加载成功：sun.misc.Unsafe@677327b6
总结：Unsafe 类的加载必须使用反射进行，否则会报错。
操作对象属性的常用方法有：
实例：
import sun.misc.Unsafe;
import j**a.lang.reflect.Field;
public class DemoTest {
private String name;
public static void main(String[] args) {
Unsafe unsafe = getUnsafe();
try {
DemoTest directMemory = (DemoTest) unsafe.allocateInstance(DemoTest.class);
//获取name属性
long nameOffset = unsafe.objectFieldOffset(DemoTest.class.getDeclaredField("name"));
//设置name属性
unsafe.putObject(directMemory, nameOffset, "并发编程");
System.out.println("属性设置成功："+ directMemory.getName());
} catch (Exception e) {
e.printStackTrace();
}
}
public static Unsafe getUnsafe() {
Unsafe unsafe = null;
try {
Field field = Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
unsafe = (Unsafe) field.get(null);
} catch (Exception e) {
e.printStackTrace();
}
return unsafe;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
结果验证：
属性设置成功：并发编程
Unsafe 操作数组元素主要有如下两个方法：
实例：
import sun.misc.Unsafe;
import j**a.lang.reflect.Field;
public class DemoTest {
private static String[] names = {"多线程", "J**a", "并发编程"};
public static void main(String[] args) {
Unsafe unsafe = getUnsafe();
try {
Class<?> a = String[].class;
int base = unsafe.arrayBaseOffset(a);
int scale = unsafe.arrayIndexScale(a);
// base + i * scale 即为字符串数组下标 i 在对象的内存中的偏移地址
System.out.println(unsafe.getObject(names, (long) base + 2 * scale));
} catch (Exception e) {
e.printStackTrace();
}
}
public static Unsafe getUnsafe() {
Unsafe unsafe = null;
try {
Field field = Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
unsafe = (Unsafe) field.get(null);
} catch (Exception e) {
e.printStackTrace();
}
return unsafe;
}
}
结果验证：
并发编程
通过对数组的元素的地址进行内存偏移，最后得到的结果为最后一个元素，并发编程。base + 2 * scale 表示字符串数组下标 i 在对象的内存中的偏移地址，偏移两个元素，得到最后一个元素。
本节内容主要对 Unsafe 类的常用方法的使用进行介绍，使学习者能够在使用 Unsafe 类操作对象和数组时，能够快速的使用课程中提供的实例思路。其实 Unsafe 类还可以操作内存地址，操作 CAS，对于初学者来说就比较晦涩了。
此处对操作对象和操作数组常用的方法的讲解，是本节的核心知识，掌握 Unsafe 类的常用方法的使用，非常重要。