Java 对象头：理解锁升级

一、简述

在HotSpot虚拟机里，对象在堆内存中的存储布局可以划分为三个部分：对象头(Header)、实例数据(Instance Data)和对齐填充(Padding)。

1️⃣【对象头】Java对象的对象头由 mark word 和 class pointer 两部分组成。

1. 对象自身的运行时数据(MarkWord)。
   存储hashcode、GC分代年龄、锁类型标记、偏向锁线程 ID、CAS锁指向线程 LockRecord 的指针等，synchronized锁的机制与这个部分(markwork)密切相关，用 markword 中最低的三位代表锁的状态，其中一位是偏向锁位，另外两位是普通锁位。

2. class pointer 存储对象的类型指针，该指针指向它的类元数据。
   值得注意的是，如果应用的对象过多，使用 64 位的指针将浪费大量内存。64 位的 JVM 比 32 位的 JVM 多耗费 50% 的内存。
   现在使用的 64 位 JVM 会默认使用选项+UseCompressedOops开启指针压缩，将指针压缩至 32 位。

2️⃣【实例数据】对象真正存储的有效信息，即在程序代码里面所定义的各种类型的字段内容，无论是从父类继承下来的，还是在子类中定义的字段都必须记录起来。这部分的存储顺序会受到虚拟机分配策略参数(-XX：FieldsAllocationStyle参数)和字段在Java源码中定义顺序的影响。HotSpot虚拟机默认的分配顺序为longs/doubles、ints、shorts/chars、bytes/booleans、oops(OrdinaryObject Pointers)。从以上默认的分配策略中可以看到，相同宽度的字段总是被分配到一起存放，在满足这个前提条件的情况下，在父类中定义的变量会出现在子类之前。如果HotSpot虚拟机的+XX：CompactFields参数值为true(默认就为true)，那子类之中较窄的变量也允许插入父类变量的空隙之中，以节省出一点点空间。

3️⃣【对齐填充】这并不是必然存在的，也没有特别的含义，它仅仅起着占位符的作用。由于HotSpot虚拟机的自动内存管理系统要求对象起始地址必须是8字节的整数倍，换句话说就是
任何对象的大小都必须是8字节的整数倍。对象头部分已经被精心设计成正好是8字节的倍数(1倍或者2倍)，因此如果对象实例数据部分没有对齐的话，就需要通过对齐填充来补全。

位(bit)、字节(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依赖：0.16版本打印格式有所不同

<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());
}

4️⃣打印结果

5️⃣打印内容说明

1. 第一行内容和锁状态内容对应

unused:1 | age:4 | biased_lock:1 | lock:2
    0       0000        0            01     代表Person对象正处于无锁状态

2. 第三行中表示的是被指针压缩为 32 位的 class pointer。
3. 第四、第六行则是 Person 对象属性信息：1 字节的 boolean 值、4 字节的 String 值。
4. 第五行alignment/padding gap【对齐/填充间隙】第一次对齐。
5. 第七行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());
    }
}

此时对象 p，对象头内容有了明显的变化，当前偏向锁偏向主线程。

五、轻量级锁

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());
        }
    }
}

thread1 中依旧输出偏向锁，主线程获取对象 p 时，thread1 虽然已经退出同步代码块，但主线程和 thread1 仍然为锁的交替竞争关系。故此时主线程输出结果为轻量级锁。

六、重量级锁

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();
}

thread1 和 thread2 同时竞争对象 p，此时输出结果为重量级锁。

七、批量重偏向和批量撤销

【批量重偏向】当一个线程创建了大量对象并执行了初始的同步操作，后来另一个线程也来将这些对象作为锁对象进行操作，会导偏向锁重偏向的操作。
【批量撤销】在多线程竞争剧烈的情况下，使用偏向锁将会降低效率，于是有了批量撤销机制。

1️⃣JVM的默认参数值
通过 JVM 的默认参数值，找一找批量重偏向和批量撤销的阈值。设置 JVM 参数-XX:+PrintFlagsFinal，在项目启动时即可输出 JVM 的默认参数值。

1. intx BiasedLockingBulkRebiasThreshold=20默认偏向锁批量重偏向阈值。
2. intx BiasedLockingBulkRevokeThreshold=40默认偏向锁批量撤销阈值。
3. 当然可以通过-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()));
}

首先，创造了 100 个偏向线程 t1 的偏向锁，偏向的线程 ID 信息为 1577900037。

再来看看重偏向的结果，线程 t2，前 19 次偏向均产生了轻量锁，而到第 20 次的时候，达到了批量重偏向的阈值 20，此时锁并不是轻量级锁，而变成了偏向锁，此时偏向的线程 t2 的 ID 信息为 1572432133。

最后再来看一下偏向结束后的对象头信息。前 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。

重头戏来了！线程 t3 也来竞争锁。因为已经达到了批量撤销的阈值，且对象 listA.get(20) 和 listA.get(22) 已经进行过偏向锁的重偏向，并不会再次重偏向线程t3。此时触发批量撤销，此时对象锁膨胀变为轻量级锁。

再来看看最后新生成的对象 Person。值得注意的是：本应该为可偏向状态偏向锁的新对象，在经历过批量重偏向和批量撤销后直接在实例化后转为无锁。

4️⃣简单总结

1. 批量重偏向和批量撤销是针对类的优化，和对象无关。
2. 偏向锁重偏向一次之后不可再次重偏向。
3. 当某个类已经触发批量撤销机制后，JVM 会默认当前类产生了严重的问题，剥夺了该类的新实例对象使用偏向锁的权利。