面试官超级喜欢问的MarkWord

开发 后端
续上次被问到synchronized锁后,面试官继续刁难阿巴阿巴,进而深入到对象头中相关的概念。

[[441998]]

前言

年底了,最近好几天没吃饭了,在微博吃瓜吃的饱饱的。

续上次被问到synchronized锁后,面试官继续刁难阿巴阿巴,进而深入到对象头中相关的概念。

当场拿offer

面试官: 上次提到了synchronized锁,那你知道synchronized锁具体是怎么实现的吗?

阿巴阿巴: 在JDK版本1.5及之前的版本synchronized主要靠的是Monitor对象来完成,同步代码块使用的是monitorenter和monitorexit指令,而synchronized修饰方法靠的是ACC_SYNCHRONIZED标识,这些都是进入到内核态进行加锁的,然后将竞争锁失败的线程直接挂起,等待后面恢复。

阿巴阿巴: 在JDK1.6及之后的版本中,synchronized锁得到了优化,引入了自适应自旋锁、偏向锁、轻量锁,他们主要优化了锁在一定条件下的性能。避免了一上来就加重量级锁,等待锁的其他线程只能乖乖挂起,对cpu性能影响特别大。

阿巴阿巴: 在hotspot虚拟机中,对象头主要包括两部分 MarkWord和Klass Pointer。

MarkWord 对象标记字段,默认存储的是对象的HashCode,GC的分代年龄(2bit最大表示15)和锁的标志信息等。对于32位的虚拟机MarkWord占32bit,对于64位的虚拟机MarkWord占用64字节。

Klass Pointer Class 对象的类型指针,它指向对象对应的Class对象的内存地址。大小占4字节(指针压缩的情况下为4字节,未进行指针压缩则占8字节)。32位虚拟机MarkWord分布

64位虚拟机MarkWord分布

图片来源https://blog.csdn.net/weixin_40816843/article/details/120811181

查看虚拟机是多少位的可以使用:java -version

面试官: 我们怎么看对象头里的MarkWord数据呢?

阿巴阿巴: 可以看到在openJDK中关于MarkWord的描述,首先可以在Github上找到Open Jdk的源码

gitHub地址:https://github.com/openjdk/jdk

在IDE中打开并找到如下的位置

src/hotspot/share/oops/markWord.hpp

  1. // 查看虚拟机是多少位的可以使用:java -version   
  2. //  32 bits: 
  3. //  -------- 
  4. //            hash:25 ------------>| age:4  unused_gap:1  lock:2 (normal object) 
  5. // 
  6. //  64 bits: 
  7. //  -------- 
  8. //  unused:25 hash:31 -->| unused_gap:1  age:4  unused_gap:1  lock:2 (normal object) 

阿巴阿巴: 当然可以引入openjdk提供的jol-core,然后进行打印即可。

  1. // 在pom中引入 
  2. <dependency> 
  3.   <groupId>org.openjdk.jol</groupId> 
  4.   <artifactId>jol-core</artifactId> 
  5.   <version>0.10</version> 
  6. </dependency> 

然后编写如下代码

  1. public static void main(String[] args) { 
  2.      Test t = new Test(); 
  3.      System.out.println(ClassLayout.parseInstance(t).toPrintable()); 
  4.  } 

打印如下

markword在哪?Klass pointer在哪儿?

1处是MarkWord占用8Byte也就是64bit

2处是Klass Pointer占用了4Byte也就是32bit

klass pointer看起来是被压缩了,怎么确定是被压缩了呢?可以通过如下命令

面试官: 对于JDK1.6及以上版本,synchronized和MarkWord有啥关系嘛?

阿巴阿巴: 那关系可大了,可以看到在MarkWord中有2bit用来表示锁的标志位,代表着经过优化的synchronized锁不会直接上重量级锁,而是由偏向锁转为轻量锁,再由轻量锁转为重量级锁,一步一步膨胀的过程。

下面是2bit的锁标志位代表的含义

  1. //    [ptr             | 00]  locked      ptr points to real header on stack 
  2. //    [header          | 01]  unlocked    regular object header 
  3. //    [ptr             | 10]  monitor     inflated lock (header is wapped out
  4. //    [ptr             | 11]  marked      used to mark an object 
  5. //    [0 ............ 0| 00]  inflating   inflation in progress 
  6.  
  7. 001  无锁状态 (第一位代表偏向标志,为0的时候表示不偏向,为1的时候表示偏向) 
  8. 101  偏向锁 且记录线程ID 
  9. 00   轻量锁 指向栈中锁记录的指针 
  10. 10   重量级锁 重量级锁的指针 
  11. 11   GC标志 

然后再找到上图Value部分的数据,这两位是锁的标志位

面试官: 你刚不是说有一位是锁的偏向标志吗?在哪儿呢?

阿巴阿巴: 锁的偏向标志就在锁标志的前一位

阿巴阿巴: 程序启动后4s就会加偏向锁,只不过这个偏向锁没有偏向任何线程ID,也属于无锁状态

阿巴阿巴: 当应用处于单线程环境中时,这时候上的是偏向锁,在对象头中偏向标示显示为1,案例如下

  1. public static void main(String[] args) { 
  2.      Test t = new Test(); 
  3.      new Thread(()->{ 
  4.          synchronized (t) { 
  5.              System.out.println(ClassLayout.parseInstance(t).toPrintable()); 
  6.          } 
  7.      }).start(); 
  8.  } 

打印出来的数据如下

阿巴阿巴: 让程序处于2个线程交替进行竞争锁

  1. public static void main(String[] args) throws InterruptedException { 
  2.         Test t = new Test(); 
  3.         Thread thread = new Thread(()->{ 
  4.             synchronized (t) { 
  5.                 System.out.println(ClassLayout.parseInstance(t).toPrintable()); 
  6.             } 
  7.  
  8.         }); 
  9.         thread.start(); 
  10.         // 等待thread运行完 
  11.         thread.join(); 
  12.          
  13.         synchronized (t) { 
  14.             System.out.println(ClassLayout.parseInstance(t).toPrintable()); 
  15.         } 
  16.     } 

可以看到当main线程拿锁时已经膨胀为轻量锁了,锁的2bit标志为变成00了

阿巴阿巴: 轻量锁的时候,虚拟机会在当前线程的栈帧中建立一个锁记录的空间“Lock Record”,用于存储锁对象目前的MarkWord的拷贝,这一步采用CAS,如果成功了,那么与此同时,2bit的锁标记位会从“01”转变为“00”。这就是加轻量锁的过程。

阿巴阿巴: 之所以引入偏向锁,是为了解决在无多线程竞争环境下的轻量锁,轻量锁CAS多次的尝试也是对性能的损耗。相对于轻量锁而言,偏向锁值只需要进行一次CAS,这次CAS是用来设置线程ID的,设置成功后就代表获取锁了。轻量锁更适合于线程交替执行的场景,它们通过CAS自旋,避免了线程直接挂起以及挂起后的恢复过程,以此来降低CPU的损耗。

阿巴阿巴: 最后让我们看看加上重量锁后的MarkWord表现吧,先上代码

  1. public static void main(String[] args) throws InterruptedException { 
  2.         Test t = new Test(); 
  3.         Thread thread = new Thread(()->{ 
  4.             synchronized (t) { 
  5.                 System.out.println(ClassLayout.parseInstance(t).toPrintable()); 
  6.             } 
  7.  
  8.         }); 
  9.         thread.start(); 
  10.         // 等待thread运行完 
  11.         // thread.join(); 去掉该代码 
  12.  
  13.         synchronized (t) { 
  14.             System.out.println(ClassLayout.parseInstance(t).toPrintable()); 
  15.         } 
  16.     } 

控制台打印如下,发现已经加上重量锁了,锁的2bit标志为变成10了。

阿巴阿巴: 当轻量级锁升级成重量级锁时,Mark Word的锁标记位更新为10,Mark Word 将指向互斥量(重量级锁)。

阿巴阿巴: 以上就是关于synchronized和MarkWord的关系啦。

面试官: 理解的不错,明天来上班吧~

阿巴阿巴: 好的~

 

责任编辑:姜华 来源: 程序员巴士
相关推荐

2021-11-08 09:18:01

CAS面试场景

2021-12-16 18:38:13

面试Synchronize

2021-12-02 18:20:25

算法垃圾回收

2022-01-05 08:56:20

Vue修饰符面试

2018-05-10 15:48:47

面试面试官Java

2020-07-28 00:58:20

IP地址子网TCP

2010-08-23 15:06:52

发问

2021-01-06 05:36:25

拉链表数仓数据

2022-01-05 09:55:26

asynawait前端

2018-01-19 10:43:06

Java面试官volatile关键字

2021-04-21 09:28:17

字节面试官SetTimeout

2010-10-27 11:07:45

面试官

2021-02-03 15:30:10

面试垃圾回收器前端

2023-06-13 07:04:27

2021-03-24 10:25:24

优化VUE性能

2023-08-02 08:48:11

C#碟片算法

2022-11-04 08:47:52

底层算法数据

2023-06-05 07:57:53

Kafka消息事务消息

2015-08-13 10:29:12

面试面试官

2021-02-07 21:16:04

字节跳动面试字符串
点赞
收藏

51CTO技术栈公众号