1、内存操作
如果你是一个写过c
或者c++
的程序员,一定对内存操作不会陌生,而在java中是不允许直接对内存进行操作的,对象内存的分配和回收都是由jvm
自己实现的。但是在Unsafe中,提供的下列接口可以直接进行内存操作:
//分配新的本地空间
public native long allocateMemory(long bytes);
//重新调整内存空间的大小
public native long reallocateMemory(long address, long bytes);
//将内存设置为指定值
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);
//清除内存
public native void freeMemory(long address);
使用下面的代码进行测试:
private void memoryTest() {
int size = 4;
long addr = unsafe.allocateMemory(size);
long addr3 = unsafe.reallocateMemory(addr, size * 2);
System.out.println("addr: "+addr);
System.out.println("addr3: "+addr3);
try {
unsafe.setMemory(null,addr ,size,(byte)1);
for (int i = 0; i < 2; i++) {
unsafe.copyMemory(null,addr,null,addr3+size*i,4);
}
System.out.println(unsafe.getInt(addr));
System.out.println(unsafe.getLong(addr3));
}finally {
unsafe.freeMemory(addr);
unsafe.freeMemory(addr3);
}
}
先看结果输出:
addr: 2433733895744
addr3: 2433733894944
16843009
72340172838076673
分析一下运行结果,首先使用allocateMemory
方法申请4字节长度的内存空间,在循环中调用setMemory
方法向每个字节写入内容为byte
类型的1,当使用Unsafe调用getInt
方法时,因为一个int
型变量占4个字节,会一次性读取4个字节,组成一个int
的值,对应的十进制结果为16843009,可以通过图示理解这个过程:
在代码中调用reallocateMemory
方法重新分配了一块8字节长度的内存空间,通过比较addr
和addr3
可以看到和之前申请的内存地址是不同的。在代码中的第二个for循环里,调用copyMemory
方法进行了两次内存的拷贝,每次拷贝内存地址addr
开始的4个字节,分别拷贝到以addr3
和addr3+4
开始的内存空间上:
拷贝完成后,使用getLong
方法一次性读取8个字节,得到long
类型的值为72340172838076673。
需要注意,通过这种方式分配的内存属于堆外内存,是无法进行垃圾回收的,需要我们把这些内存当做一种资源去手动调用freeMemory
方法进行释放,否则会产生内存泄漏。通用的操作内存方式是在try
中执行对内存的操作,最终在finally
块中进行内存的释放。
2、内存屏障
在介绍内存屏障前,需要知道编译器和CPU会在保证程序输出结果一致的情况下,会对代码进行重排序,从指令优化角度提升性能。而指令重排序可能会带来一个不好的结果,导致CPU的高速缓存和内存中数据的不一致,而内存屏障(Memory Barrier
)就是通过组织屏障两边的指令重排序从而避免编译器和硬件的不正确优化情况。
在硬件层面上,内存屏障是CPU为了防止代码进行重排序而提供的指令,不同的硬件平台上实现内存屏障的方法可能并不相同。在java8中,引入了3个内存屏障的函数,它屏蔽了操作系统底层的差异,允许在代码中定义、并统一由jvm来生成内存屏障指令,来实现内存屏障的功能。Unsafe中提供了下面三个内存屏障相关方法:
//禁止读操作重排序
public native void loadFence();
//禁止写操作重排序
public native void storeFence();
//禁止读、写操作重排序
public native void fullFence();
内存屏障可以看做对内存随机访问的操作中的一个同步点,使得此点之前的所有读写操作都执行后才可以开始执行此点之后的操作。以loadFence
方法为例,它会禁止读操作重排序,保证在这个屏障之前的所有读操作都已经完成,并且将缓存数据设为无效,重新从主存中进行加载。
看到这估计很多小伙伴们会想到volatile
关键字了,如果在字段上添加了volatile
关键字,就能够实现字段在多线程下的可见性。基于读内存屏障,我们也能实现相同的功能。下面定义一个线程方法,在线程中去修改flag
标志位,注意这里的flag
是没有被volatile
修饰的:
@Getter
class ChangeThread implements Runnable{
/volatile/ boolean flag=false;
@Override
public void run() {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(“subThread change flag to:” + flag);
flag = true;
}
}
在主线程的while
循环中,加入内存屏障,测试是否能够感知到flag
的修改变化:
public static void main(String[] args){
ChangeThread changeThread = new ChangeThread();
new Thread(changeThread).start();
while (true) {
boolean flag = changeThread.isFlag();
unsafe.loadFence(); //加入读内存屏障
if (flag){
System.out.println(“detected flag changed”);
break;
}
}
System.out.println(“main thread end”);
}
运行结果:
subThread change flag to:false
detected flag changed
main thread end
而如果删掉上面代码中的loadFence
方法,那么主线程将无法感知到flag
发生的变化,会一直在while
中循环。可以用图来表示上面的过程:
了解java内存模型(JMM
)的小伙伴们应该清楚,运行中的线程不是直接读取主内存中的变量的,只能操作自己工作内存中的变量,然后同步到主内存中,并且线程的工作内存是不能共享的。上面的图中的流程就是子线程借助于主内存,将修改后的结果同步给了主线程,进而修改主线程中的工作空间,跳出循环。
3、对象操作
a、对象成员属性的内存偏移量获取,以及字段属性值的修改,在上面的例子中我们已经测试过了。除了前面的putInt
、getInt
方法外,Unsafe提供了全部8种基础数据类型以及Object
的put
和get
方法,并且所有的put
方法都可以越过访问权限,直接修改内存中的数据。阅读openJDK源码中的注释发现,基础数据类型和Object
的读写稍有不同,基础数据类型是直接操作的属性值(value
),而Object
的操作则是基于引用值(reference value
)。下面是Object
的读写方法:
//在对象的指定偏移地址获取一个对象引用
public native Object getObject(Object o, long offset);
//在对象指定偏移地址写入一个对象引用
public native void putObject(Object o, long offset, Object x);
除了对象属性的普通读写外,Unsafe还提供了volatile读写和有序写入方法。volatile
读写方法的覆盖范围与普通读写相同,包含了全部基础数据类型和Object
类型,以int
类型为例:
//在对象的指定偏移地址处读取一个int值,支持volatile load语义
public native int getIntVolatile(Object o, long offset);
//在对象指定偏移地址处写入一个int,支持volatile store语义
public native void putIntVolatile(Object o, long offset, int x);
相对于普通读写来说,volatile
读写具有更高的成本,因为它需要保证可见性和有序性。在执行get
操作时,会强制从主存中获取属性值,在使用put
方法设置属性值时,会强制将值更新到主存中,从而保证这些变更对其他线程是可见的。
有序写入的方法有以下三个:
public native void putOrderedObject(Object o, long offset, Object x);
public native void putOrderedInt(Object o, long offset, int x);
public native void putOrderedLong(Object o, long offset, long x);
有序写入的成本相对volatile
较低,因为它只保证写入时的有序性,而不保证可见性,也就是一个线程写入的值不能保证其他线程立即可见。为了解决这里的差异性,需要对内存屏障的知识点再进一步进行补充,首先需要了解两个指令的概念:
-
Load
:将主内存中的数据拷贝到处理器的缓存中 -
Store
:将处理器缓存的数据刷新到主内存中
顺序写入与volatile
写入的差别在于,在顺序写时加入的内存屏障类型为StoreStore
类型,而在volatile
写入时加入的内存屏障是StoreLoad
类型,如下图所示:
在有序写入方法中,使用的是StoreStore
屏障,该屏障确保Store1
立刻刷新数据到内存,这一操作先于Store2
以及后续的存储指令操作。而在volatile
写入中,使用的是StoreLoad
屏障,该屏障确保Store1
立刻刷新数据到内存,这一操作先于Load2
及后续的装载指令,并且,StoreLoad
屏障会使该屏障之前的所有内存访问指令,包括存储指令和访问指令全部完成之后,才执行该屏障之后的内存访问指令。
综上所述,在上面的三类写入方法中,在写入效率方面,按照put
、putOrder
、putVolatile
的顺序效率逐渐降低,
b、使用Unsafe的allocateInstance
方法,允许我们使用非常规的方式进行对象的实例化,首先定义一个实体类,并且在构造函数中对其成员变量进行赋值操作:
@Data
public class A {
private int b;
public A(){
this.b =1;
}
}
分别基于构造函数、反射以及Unsafe方法的不同方式创建对象进行比较:
public void objTest() throws Exception{
A a1=new A();
System.out.println(a1.getB());
A a2 = A.class.newInstance();
System.out.println(a2.getB());
A a3= (A) unsafe.allocateInstance(A.class);
System.out.println(a3.getB());
}
打印结果分别为1、1、0,说明通过allocateInstance
方法创建对象过程中,不会调用类的构造方法。使用这种方式创建对象时,只用到了Class
对象,所以说如果想要跳过对象的初始化阶段或者跳过构造器的安全检查,就可以使用这种方法。在上面的例子中,如果将A类的构造函数改为private
类型,将无法通过构造函数和反射创建对象,但allocateInstance
方法仍然有效。
4、数组操作
在Unsafe中,可以使用arrayBaseOffset
方法可以获取数组中第一个元素的偏移地址,使用arrayIndexScale
方法可以获取数组中元素间的偏移地址增量。使用下面的代码进行测试:
private void arrayTest() {
String[] array=new String[]{“str1str1str”,“str2”,“str3”};
int baseOffset = unsafe.arrayBaseOffset(String[].class);
System.out.println(baseOffset);
int scale = unsafe.arrayIndexScale(String[].class);
System.out.println(scale);
for (int i = 0; i < array.length; i++) {
int offset=baseOffset+scale*i;
System.out.println(offset+" : "+unsafe.getObject(array,offset));
}
}
上面代码的输出结果为:
16
4
16 : str1str1str
20 : str2
24 : str3
通过配合使用数组偏移首地址和各元素间偏移地址的增量,可以方便的定位到数组中的元素在内存中的位置,进而通过getObject
方法直接获取任意位置的数组元素。需要说明的是,arrayIndexScale
获取的并不是数组中元素占用的大小,而是地址的增量,按照openJDK中的注释,可以将它翻译为元素寻址的转换因子(scale factor for addressing elements
)。在上面的例子中,第一个字符串长度为11字节,但其地址增量仍然为4字节。
那么,基于这两个值是如何实现的寻址和数组元素的访问呢,这里需要借助一点在前面的文章中讲过的Java对象内存布局的知识,先把上面例子中的String数组对象的内存布局画出来,就很方便大家理解了:
在String数组对象中,对象头包含3部分,mark word
标记字占用8字节,klass point
类型指针占用4字节,数组对象特有的数组长度部分占用4字节,总共占用了16字节。第一个String的引用类型相对于对象的首地址的偏移量是就16,之后每个元素在这个基础上加4,正好对应了我们上面代码中的寻址过程,之后再使用前面说过的getObject
方法,通过数组对象可以获得对象在堆中的首地址,再配合对象中变量的偏移量,就能获得每一个变量的引用。
5、CAS操作
在juc
包的并发工具类中大量地使用了CAS操作,像在前面介绍synchronized
和AQS
的文章中也多次提到了CAS,其作为乐观锁在并发工具类中广泛发挥了作用。在Unsafe类中,提供了compareAndSwapObject
、compareAndSwapInt
、compareAndSwapLong
方法来实现的对Object
、int
、long
类型的CAS操作。以compareAndSwapInt
方法为例:
public final native boolean compareAndSwapInt(Object o, long offset,int expected,int x);
参数中o
为需要更新的对象,offset
是对象o
中整形字段的偏移量,如果这个字段的值与expected
相同,则将字段的值设为x
这个新值,并且此更新是不可被中断的,也就是一个原子操作。下面是一个使用compareAndSwapInt
的例子:
private volatile int a;
public static void main(String[] args){
CasTest casTest=new CasTest();
new Thread(()->{
for (int i = 1; i < 5; i++) {
casTest.increment(i);
System.out.print(casTest.a+" ");
}
}).start();
new Thread(()->{
for (int i = 5 ; i <10 ; i++) {
casTest.increment(i);
System.out.print(casTest.a+" ");
}
}).start();
}
private void increment(int x){
while (true){
try {
long fieldOffset = unsafe.objectFieldOffset(CasTest.class.getDeclaredField(“a”));
if (unsafe.compareAndSwapInt(this,fieldOffset,x-1,x))
break;
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
}
}
运行代码会依次输出:
1 2 3 4 5 6 7 8 9
在上面的例子中,使用两个线程去修改int
型属性a
的值,并且只有在a
的值等于传入的参数x
减一时,才会将a
的值变为x
,也就是实现对a
的加一的操作。流程如下所示:
需要注意的是,在调用compareAndSwapInt
方法后,会直接返回true
或false
的修改结果,因此需要我们在代码中手动添加自旋的逻辑。在AtomicInteger
类的设计中,也是采用了将compareAndSwapInt
的结果作为循环条件,直至修改成功才退出死循环的方式来实现的原子性的自增操作。
6、线程调度
Unsafe类中提供了park
、unpark
、monitorEnter
、monitorExit
、tryMonitorEnter
方法进行线程调度,在前面介绍AQS的文章中我们提到过使用LockSupport
挂起或唤醒指定线程,看一下LockSupport
的源码,可以看到它也是调用的Unsafe类中的方法:
public static void park(Object blocker) {
Thread t = Thread.currentThread();
setBlocker(t, blocker);
UNSAFE.park(false, 0L);
setBlocker(t, null);
}
public static void unpark(Thread thread) {
if (thread != null)
UNSAFE.unpark(thread);
}
LockSupport的park
方法调用了Unsafe的park
方法来阻塞当前线程,此方法将线程阻塞后就不会继续往后执行,直到有其他线程调用unpark
方法唤醒当前线程。下面的例子对Unsafe的这两个方法进行测试:
public static void main(String[] args) {
Thread mainThread = Thread.currentThread();
new Thread(()->{
try {
TimeUnit.SECONDS.sleep(5);
System.out.println(“subThread try to unpark mainThread”);
unsafe.unpark(mainThread);
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
System.out.println(“park main mainThread”);
unsafe.park(false,0L);
System.out.println(“unpark mainThread success”);
}
程序输出为:
park main mainThread
subThread try to unpark mainThread
unpark mainThread success
程序运行的流程也比较容易看懂,子线程开始运行后先进行睡眠,确保主线程能够调用park
方法阻塞自己,子线程在睡眠5秒后,调用unpark
方法唤醒主线程,使主线程能继续向下执行。整个流程如下图所示:
此外,Unsafe源码中monitor
相关的三个方法已经被标记为deprecated
,不建议被使用:
//获得对象锁
@Deprecated
public native void monitorEnter(Object var1);
//释放对象锁
@Deprecated
public native void monitorExit(Object var1);
//尝试获得对象锁
@Deprecated
public native boolean tryMonitorEnter(Object var1);
monitorEnter
方法用于获得对象锁,monitorExit
用于释放对象锁,如果对一个没有被monitorEnter
加锁的对象执行此方法,会抛出IllegalMonitorStateException
异常。tryMonitorEnter
方法尝试获取对象锁,如果成功则返回true
,反之返回false
。
7、Class操作
Unsafe对Class
的相关操作主要包括类加载和静态变量的操作方法。
最后
无论是哪家公司,都很重视基础,大厂更加重视技术的深度和广度,面试是一个双向选择的过程,不要抱着畏惧的心态去面试,不利于自己的发挥。同时看中的应该不止薪资,还要看你是不是真的喜欢这家公司,是不是能真的得到锻炼。
针对以上面试技术点,我在这里也做一些分享,希望能更好的帮助到大家。
//获得对象锁
@Deprecated
public native void monitorEnter(Object var1);
//释放对象锁
@Deprecated
public native void monitorExit(Object var1);
//尝试获得对象锁
@Deprecated
public native boolean tryMonitorEnter(Object var1);
monitorEnter
方法用于获得对象锁,monitorExit
用于释放对象锁,如果对一个没有被monitorEnter
加锁的对象执行此方法,会抛出IllegalMonitorStateException
异常。tryMonitorEnter
方法尝试获取对象锁,如果成功则返回true
,反之返回false
。
7、Class操作
Unsafe对Class
的相关操作主要包括类加载和静态变量的操作方法。
最后
无论是哪家公司,都很重视基础,大厂更加重视技术的深度和广度,面试是一个双向选择的过程,不要抱着畏惧的心态去面试,不利于自己的发挥。同时看中的应该不止薪资,还要看你是不是真的喜欢这家公司,是不是能真的得到锻炼。
针对以上面试技术点,我在这里也做一些分享,希望能更好的帮助到大家。
[外链图片转存中…(img-iRto3nbi-1714344277228)]
[外链图片转存中…(img-OO8lPhgn-1714344277229)]
[外链图片转存中…(img-UemA1Y25-1714344277229)]