摘要:它的目的是为了增强语言直接操作底层资源的能力,无疑带来很多方便。这样可以有效避免多线程环境下的同步问题。另外还有的匿名内部类的生成,数组内存操作等。
简介</>复制代码
本文原创地址,我的博客:jsbintask的博客(食用效果最佳),转载请注明出处!
Unsafe是jdk提供的一个直接访问操作系统资源的工具类(底层c++实现),它可以直接分配内存,内存复制,copy,提供cpu级别的CAS乐观锁等操作。它的目的是为了增强java语言直接操作底层资源的能力,无疑带来很多方便。但是,使用的同时就得额外小心!它的总体作用如下(图片来源网络):
Unsafe位于sun.misc包下,jdk中的并发编程包juc(java.util.concurrent)基本全部靠Unsafe实现,由此可见其重要性。
基本使用Unsafe被设计为单例,并且只允许被引导类加载器(BootstrapClassLoader)加载的类使用:
</>复制代码
public static void main(String[] args) throws Exception{
// method 1
Class unsafeClass = Unsafe.class;
Constructor constructor = unsafeClass.getDeclaredConstructor();
constructor.setAccessible(true);
Unsafe unsafe1 = constructor.newInstance();
System.out.println(unsafe1);
// method2
Field theUnsafe = unsafeClass.getDeclaredField("theUnsafe");
theUnsafe.setAccessible(true);
Unsafe unsafe2 = (Unsafe) theUnsafe.get(null);
System.out.println(unsafe2);
}
CAS
CAS译为Compare And Swap,它是乐观锁的一种实现。假设内存值为v,预期值为e,想要更新成得值为u,当且仅当内存值v等于预期值e时,才将v更新为u。 这样可以有效避免多线程环境下的同步问题。
在unsafe中,实现CAS算法通过cpu的原子指令cmpxchg实现,它对应的方法如下:
为了方便理解,举个栗子。类User有一个成员变量name。我们new了一个对象User后,就知道了它在内存中的起始值,而成员变量name在对象中的位置偏移是固定的。这样通过这个起始值和这个偏移量就能够定位到name在内存中的具体位置。
所以我们现在的问题就是如何得出name在对象User中的偏移量,Unsafe自然也提供了相应的方法:
</>复制代码
public class UnsafeTest {
public static void main(String[] args) throws Exception {
Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
theUnsafe.setAccessible(true);
Unsafe unsafe = (Unsafe) theUnsafe.get(null);
User user = new User("jsbintask");
long nameOffset = unsafe.objectFieldOffset(User.class.getDeclaredField("name"));
unsafe.compareAndSwapObject(user, nameOffset, "jsbintask1", "jsbintask2");
System.out.println("第一次更新后的值:" + user.getName());
unsafe.compareAndSwapObject(user, nameOffset, "jsbintask", "jsbintask2");
System.out.println("第二次更新后的值:" + user.getName());
}
}
class User {
private String name;
public User(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
如果我们分析juc包下的Atomic开头的原子类就会发现,它内部的原子操作全部来源于unsafe的CAS方法,比如AtomicInteger的getAndIncrement方法,内部直接调用unsafe的getAndAddInt方法,它的实现原理为:cas失败,就循环,直到成功为止,这就是我们所说的自旋锁!
内存分配
Unsafe还给我们提供了直接分配内存,释放内存,拷贝内存,内存设置等方法,值得注意的是,这里的内存指的是堆外内存!它是不受jvm内存模型掌控的,所以使用需要及其小心:
</>复制代码
//分配内存, 相当于C++的malloc函数
public native long allocateMemory(long bytes);
//释放内存
public native void freeMemory(long address);
//在给定的内存块中设置值
public native void setMemory(Object o, long offset, long bytes, byte value);
//内存拷贝
public native void copyMemory(Object srcBase, long srcOffset, Object destBase, long destOffset, long bytes);
//为给定地址设置值,忽略修饰限定符的访问限制,与此类似操作还有: putInt,putDouble,putLong,putChar等
public native void putObject(Object o, long offset, Object x);
我们可以写一段代码验证一下:
</>复制代码
public static void main(String[] args) throws Exception {
Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
theUnsafe.setAccessible(true);
Unsafe unsafe = (Unsafe) theUnsafe.get(null);
// 分配 10M的堆外内存
long _10M_Address = unsafe.allocateMemory(1 * 1024 * 1024 * 10);
// 将10M内存的 前面1M内存值设置为10
unsafe.setMemory(_10M_Address, 1 * 1024 * 1024 * 1, (byte) 10);
// 获取第1M内存的值: 10
System.out.println(unsafe.getByte(_10M_Address + 1000));
// 获取第1M内存后的值: 0(没有设置)
System.out.println(unsafe.getByte(_10M_Address + 1 * 1024 * 1024 * 5));
}
堆外内存不受jvm内存模型掌控,在nio(netty,mina)中大量使用对外内存进行管道传输,copy等,使用它们的好处如下:
对垃圾回收停顿的改善。由于堆外内存是直接受操作系统管理而不是JVM,所以当我们使用堆外内存时,即可保持较小的堆内内存规模。从而在GC时减少回收停顿对于应用的影响。
提升程序I/O操作的性能。通常在I/O通信过程中,会存在堆内内存到堆外内存的数据拷贝操作,对于需要频繁进行内存间数据拷贝且生命周期较短的暂存数据,都建议存储到堆外内存。 而在jdk中,堆外内存对应的类为DirectByteBuffer,它内部也是通过unsafe分配的内存:
通过Unsafe还可以直接将某个线程挂起,这和调用Object.wait()方法作用是一样的,但是效率确更高!
</>复制代码
public static void main(String[] args) throws Exception {
Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
theUnsafe.setAccessible(true);
Unsafe unsafe = (Unsafe) theUnsafe.get(null);
Thread t1 = new Thread(() -> {
for (int i = 0; i < 10; i++) {
if (i == 5) {
// i == 5时,将当前线程挂起
unsafe.park(false, 0L);
}
System.out.println(Thread.currentThread().getName() + " printing i : " + i);
}
}, " Thread__Unsafe__1");
t1.start();
// 主线程休息三秒
Thread.sleep(3000L);
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + " printing i : " + i);
if (i == 9) {
// 将线程 t1 唤醒
unsafe.unpark(t1);
}
}
System.in.read();
}
数组操作
对于数组,Unsafe提供了特别的方法返回不同类型数组在内存中的偏移量:
</>复制代码
public static void main(String[] args) throws Exception{
Class unsafeClass = Unsafe.class;
Constructor constructor = unsafeClass.getDeclaredConstructor();
constructor.setAccessible(true);
Unsafe unsafe = constructor.newInstance();
Integer[] integers = new Integer[10];
// 打印数组的原始值
System.out.println(Arrays.toString(integers));
// 获取Integer数组在内存中的固定的偏移量
long arrayBaseOffset = unsafe.arrayBaseOffset(Integer[].class);
System.out.println(unsafe.arrayIndexScale(Integer[].class));
System.out.println(unsafe.arrayIndexScale(double[].class));
// 将数组中第一个元素的更新为100
unsafe.putObject(integers, arrayBaseOffset, 100);
// 将数组中第五个元素更新为50 注意 引用类型占用4个字节,所以内存地址 需要 4 * 4 = 16
unsafe.putObject(integers, arrayBaseOffset + 16, 50);
// 打印更新后的值
System.out.println(Arrays.toString(integers));
}
数组的原子操作,juc包也已经提供了相应的工具类,比如AtomicIntegerArray内部就是同过Unsafe的上述方法实现了数组的原子操作。
其它操作
Unsafe还提供了操作系统级别的方法如获取内存页的大小public native int pageSize();,获取系统指针大小public native int addressSize(); jdk8还加入了新的方法,内存屏障,它的目的是为了防止指令重排序(编译器为了优化速度,会在保证单线程不出错的情况下将某些代码的顺序调换,比如先分配内存,或者先返回引用等,这样在多线程环境下就会出错):
</>复制代码
//内存屏障,禁止load操作重排序。屏障前的load操作不能被重排序到屏障后,屏障后的load操作不能被重排序到屏障前
public native void loadFence();
//内存屏障,禁止store操作重排序。屏障前的store操作不能被重排序到屏障后,屏障后的store操作不能被重排序到屏障前
public native void storeFence();
//内存屏障,禁止load、store操作重排序
public native void fullFence();
jdk1.8引入的StampedLock就是基于此实现的乐观读写锁. 另外,jdk1.8引入了lambda表达式,它其实会帮我们调用Unsafe的public native Class<");方法生成匿名内部类,如下面的代码:
</>复制代码
public class UnsafeTest2 {
public static void main(String[] args) {
Function function = Integer::parseInt;
System.out.println(function.apply("100"));
}
}
查看字节码:
总结
通过反射可以获取Unsafe类的实例,他可以帮助我们进行堆外内存操作,内存copy,内存复制,线程挂起,提供了cpu级别的cas原子操作。另外还有lambda的匿名内部类的生成,数组内存操作等。juc包基本全部基于此类实现!
关注我,这里只有干货!
文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。
转载请注明本文地址:https://www.ucloud.cn/yun/7198.html
摘要:表示一个异步任务的结果,就是向线程池提交一个任务后,它会返回对应的对象。它们分别提供两个重要的功能阻塞当前线程等待一段时间直到完成或者异常终止取消任务。此时,线程从中返回,然后检查当前的状态已经被改变,随后退出循环。 0 引言 前段时间需要把一个C++的项目port到Java中,因此时隔三年后重新熟悉了下Java。由于需要一个通用的线程池,自然而然就想到了Executors。 用了...
摘要:恢复流程如下判断当前中的是否已标注为处理从链表中删除已标注中止的事件,也就是删除已经被恢复的事件将相关需要恢复的栈帧信息传递给方法的参数每个栈帧对应着一个未运行完的函数。 作为一个 gophper,我相信你对于 panic 和 recover 肯定不陌生,但是你有没有想过。当我们执行了这两条语句之后。底层到底发生了什么事呢?前几天和同事刚好聊到相关的话题,发现其实大家对这块理解还是比较...
摘要:因为它是不安全的,但是在特殊的场景下,使用了它。可以打破的类型和内存安全机制,让你获得眼前一亮的惊喜效果 在上一篇文章 《深入理解 Go Slice》 中,大家会发现其底层数据结构使用了 unsafe.Pointer。因此想着再介绍一下其关联知识 原文地址:有点不安全却又一亮的 Go unsafe.Pointer 前言 在大家学习 Go 的时候,肯定都学过 Go 的指针是不支持指针运算...
阅读 2449·2021-11-23 09:51
阅读 1252·2021-11-22 13:54
阅读 3480·2021-09-24 10:31
阅读 1161·2021-08-16 10:46
阅读 3682·2019-08-30 15:54
阅读 745·2019-08-30 15:54
阅读 2927·2019-08-29 17:17
阅读 3210·2019-08-29 15:08