一、简述
在 JVM 中，对象在堆内存中的布局分为三块区域：对象头、实例变量和填充数据。
1️⃣【对象头区域】Java对象的对象头由 mark word 和 class pointer 两部分组成。
对象自身的运行时数据(MarkWord)。
存储 hashcode、GC 分代年龄、锁类型标记、偏向锁线程 ID、CAS 锁指向线程 LockRecord 的指针等，synchronized 锁的机制与这个部分(markwork)密切相关，用 markword 中最低的三位代表锁的状态，其中一位是偏向锁位，另外两位是普通锁位。class pointer 存储对象的类型指针，该指针指向它的类元数据。
值得注意的是，如果应用的对象过多，使用 64 位的指针将浪费大量内存。64 位的 JVM 比 32 位的 JVM 多耗费 50% 的内存。
现在使用的 64 位 JVM 会默认使用选项+UseCompressedOops开启指针压缩，将指针压缩至 32 位。
2️⃣【实例数据区域】存放类的属性数据信息，包括父类的属性信息，如果是数组的实例部分还包括数组的长度，这部分内存按 4 字节对齐。
3️⃣【对齐填充区域】JVM 的实现 HostSpot 规定对象的起始地址必须是 8 字节的整数倍，换句话来说，现在 64 bit/位 的 OS 往外读取数据的时候一次性读取 64 bit/位 整数倍的数据，也就是 8 个 byte/字节，所以 HotSpot 为了高效读取对象，就做了“对齐”，如果一个对象实际占用的内存大小不是 8 byte/字节 的整数倍时，就“补位”到 8 byte/字节 的整数倍。所以对齐填充区域的数据不是必须存在的，仅仅是为了字节对齐，当然大小也不是固定的。
二、对象头存储内容
以 64 位操作系统为例，对象头存储内容图例。
1️⃣lock：锁状态标记位。该标记的值不同，整个 mark word 表示的含义不同。
2️⃣biased_lock：偏向锁标记。为 1 时表示对象启用偏向锁，为 0 时表示对象没有偏向锁。
3️⃣age：Java GC 标记位对象年龄。
4️⃣identity_hashcode：对象标识 Hash 值，采用延迟加载技术。当对象使用 HashCode() 计算后，并会将结果写到该对象头中。当对象被锁定时，该值会移动到线程 Monitor 中。
5️⃣thread：持有偏向锁的线程 ID 和其他信息。这个线程 ID 并不是 JVM 分配的线程 ID 号，和 Java Thread 中的 ID 是两个概念。
6️⃣epoch：偏向时间戳。
7️⃣ptr_to_lock_record：指向栈中锁记录的指针。
8️⃣ptr_to_heavyweight_monitor：指向线程 Monitor 的指针。
三、打印对象头
1️⃣maven 依赖
<dependency>
<groupId>org.openjdk.jol</groupId>
<artifactId>jol-core</artifactId>
<version>0.8</version>
</dependency>
2️⃣创建对象 Person
@Data
public class Person {
private String name;
private boolean flag;
}
3️⃣使用 jol 工具打印 Person 对象的对象头
public static void main(String[] args) {
Person p = new Person();
System.out.println(ClassLayout.parseInstance(p).toPrintable());
}
5️⃣打印内容说明
- 第一行内容和锁状态内容对应
unused:1 | age:4 | biased_lock:1 | lock:2
0 0000 0 01 代表Person对象正处于无锁状态
- 第三行中表示的是被指针压缩为 32 位的 class pointer。
- 第四、第六行则是 Person 对象属性信息：1 字节的 boolean 值、4 字节的 String 值。
- 第五行
alignment/padding gap【对齐/填充间隙】第一次对齐。 - 第七行
loss due to the next object alignment【下一个对象对齐导致的损失】说明为了凑齐 64 bit/位【8 byte/字节】的对象，对齐字段占用了 4 byte/字节，即 32 bit/位。
6️⃣注释掉private boolean flag;即：
@Data
public class Person {
private String name;
}
7️⃣修改 Person 对象如下：
@Data
public class Person {
private boolean flag;
private boolean flag1;
}
四、偏向锁
public static void main(String[] args) throws InterruptedException {
Thread.sleep(5000);
Person p = new Person();
System.out.println(ClassLayout.parseInstance(p).toPrintable());
}
1️⃣为什么睡眠了 5s，Person 对象就由无锁状态变成了偏向锁？JVM 启动时会进行一系列的复杂活动，比如装载配置，系统类初始化等等。在这个过程中会使用大量 synchronized 关键字对对象加锁，且这些锁大多数都不是偏向锁。为了减少初始化时间，JVM 默认延时加载偏向锁。这个延时的时间大概为 4s 左右，具体时间因机器而异。当然也可以设置 JVM 参数-XX:BiasedLockingStartupDelay=0来取消延时加载偏向锁。
2️⃣可是这并没使用 synchronized 关键字，不应该是无锁吗？怎么会是偏向锁呢？仔细看一下偏向锁的组成，对照输出结果红色划线位置，发现占用 thread 和 epoch 的位置的均为 0，说明当前偏向锁并没有偏向任何线程。此时这个偏向锁正处于可偏向状态，准备好进行偏向了！可以理解为此时的偏向锁是一个特殊状态的无锁。
3️⃣再来看这段代码，使用了 synchronized 关键字
public static void main(String[] args) throws InterruptedException {
Thread.sleep(5000);
Person p = new Person();
synchronized (p) {
System.out.println(ClassLayout.parseInstance(p).toPrintable());
}
}
五、轻量级锁
public class OopTest {
public static void main(String[] args) throws Exception {
Thread.sleep(5000);
Person p = new Person();
Thread thread1 = new Thread() {
@Override
public void run() {
synchronized (p) {
System.out.println("thread1 locking");
//偏向锁
System.out.println(ClassLayout.parseInstance(p).toPrintable());
}
}
};
thread1.start();
thread1.join();
Thread.sleep(10000);
synchronized (p) {
System.out.println("main locking");
//轻量锁
System.out.println(ClassLayout.parseInstance(p).toPrintable());
}
}
}
六、重量级锁
public static void main(String[] args) throws InterruptedException {
Thread.sleep(5000);
Person p = new Person();
Thread thread1 = new Thread() {
@Override
public void run() {
synchronized (p) {
System.out.println("thread1 locking");
System.out.println(ClassLayout.parseInstance(p).toPrintable());
try {
//让线程晚点儿死亡，造成锁的竞争
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
Thread thread2 = new Thread() {
@Override
public void run() {
synchronized (p) {
System.out.println("thread2 locking");
System.out.println(ClassLayout.parseInstance(p).toPrintable());
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
thread1.start();
thread2.start();
}
七、批量重偏向和批量撤销
【批量重偏向】当一个线程创建了大量对象并执行了初始的同步操作，后来另一个线程也来将这些对象作为锁对象进行操作，会导偏向锁重偏向的操作。
【批量撤销】在多线程竞争剧烈的情况下，使用偏向锁将会降低效率，于是有了批量撤销机制。
1️⃣JVM的默认参数值
通过 JVM 的默认参数值，找一找批量重偏向和批量撤销的阈值。设置 JVM 参数-XX:+PrintFlagsFinal，在项目启动时即可输出 JVM 的默认参数值。
-
intx BiasedLockingBulkRebiasThreshold=20默认偏向锁批量重偏向阈值。 -
intx BiasedLockingBulkRevokeThreshold=40默认偏向锁批量撤销阈值。 - 当然可以通过
-XX:BiasedLockingBulkRebiasThreshold和-XX:BiasedLockingBulkRevokeThreshold来手动设置阈值。
2️⃣批量重偏向
public static void main(String[] args) throws Exception {
//延时产生可偏向对象
Thread.sleep(5000);
//创造100个偏向线程t1的偏向锁
List<Person> listP = new ArrayList<>();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 100; i++) {
Person p = new Person();
synchronized (p) {
listP.add(p);
}
}
try {
//为了防止JVM线程复用，在创建完对象后，保持线程t1状态为存活
Thread.sleep(100000000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
t1.start();
//睡眠3s钟保证线程t1创建对象完成
Thread.sleep(3000);
System.out.println("打印t1线程，list中第20个对象的对象头：");
System.out.println((ClassLayout.parseInstance(listP.get(19)).toPrintable()));
//创建线程t2竞争线程t1中已经退出同步块的锁
Thread t2 = new Thread(() -> {
//这里面只循环了30次！！！
for (int i = 0; i < 30; i++) {
Person p = listP.get(i);
synchronized (p) {
//分别打印第19次和第20次偏向锁重偏向结果
if (i == 18 || i == 19) {
System.out.println("第" + (i + 1) + "次偏向结果");
System.out.println((ClassLayout.parseInstance(p).toPrintable()));
}
}
}
try {
Thread.sleep(10000000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
t2.start();
Thread.sleep(3000);
System.out.println("打印list中第11个对象的对象头：");
System.out.println((ClassLayout.parseInstance(listP.get(10)).toPrintable()));
System.out.println("打印list中第26个对象的对象头：");
System.out.println((ClassLayout.parseInstance(listP.get(25)).toPrintable()));
System.out.println("打印list中第41个对象的对象头：");
System.out.println((ClassLayout.parseInstance(listP.get(40)).toPrintable()));
}
最后再来看一下偏向结束后的对象头信息。前 20 个对象，并没有触发了批量重偏向机制，线程 t2 执行释放同步锁后，转变为无锁形态。第 20~30 个对象，触发了批量重偏向机制，对象为偏向锁状态，偏向线程 t2，线程 t2 的 ID 信息为 1572432133。
而 31 个对象之后，也没有触发了批量重偏向机制，对象仍偏向线程 t1，线程 t1 的 ID 信息为 1577900037。
3️⃣批量撤销
public static void main(String[] args) throws Exception {
Thread.sleep(5000);
List<Person> listP = new ArrayList<>();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 100; i++) {
Person p = new Person();
synchronized (p) {
listP.add(p);
}
}
try {
Thread.sleep(100000000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
t1.start();
Thread.sleep(3000);
Thread t2 = new Thread(() -> {
//这里循环了40次。达到了批量撤销的阈值
for (int i = 0; i < 40; i++) {
Person e = listP.get(i);
synchronized (e) {
}
}
try {
Thread.sleep(10000000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
t2.start();
//———————————分割线，前面代码不再赘述——————————————————————————————————————————
Thread.sleep(3000);
System.out.println("打印list中第11个对象的对象头：");
System.out.println((ClassLayout.parseInstance(listP.get(10)).toPrintable()));
System.out.println("打印list中第26个对象的对象头：");
System.out.println((ClassLayout.parseInstance(listP.get(25)).toPrintable()));
System.out.println("打印list中第90个对象的对象头：");
System.out.println((ClassLayout.parseInstance(listP.get(89)).toPrintable()));
Thread t3 = new Thread(() -> {
for (int i = 20; i < 40; i++) {
Person r = listP.get(i);
synchronized (r) {
if (i == 20 || i == 22) {
System.out.println("thread3 第" + i + "次");
System.out.println((ClassLayout.parseInstance(r).toPrintable()));
}
}
}
});
t3.start();
Thread.sleep(10000);
System.out.println("重新输出新实例Person");
System.out.println((ClassLayout.parseInstance(new Person()).toPrintable()));
}
来看看输出结果，这部分和上面批量偏向结果的大相径庭。重点关注记录的线程 ID 信息。前 20 个对象，并没有触发了批量重偏向机制，线程 t2 执行释放同步锁后，转变为无锁形态。第 20~40 个对象，触发了批量重偏向机制，对象为偏向锁状态，偏向线程 t2，线程 t2 的 ID 信息为 -761562875。
而 41 个对象之后，也没有触发了批量重偏向机制，对象仍偏向线程 t1，线程 t1 的ID信息为 -787705851。
4️⃣简单总结
- 批量重偏向和批量撤销是针对类的优化，和对象无关。
- 偏向锁重偏向一次之后不可再次重偏向。
- 当某个类已经触发批量撤销机制后，JVM 会默认当前类产生了严重的问题，剥夺了该类的新实例对象使用偏向锁的权利。
