了解Synchronized对象头？

1、对象头的结构

Java对象存储在内存中结构为：

1. 对象头（Header）：
2. 实例数据（Instance Data）：定义类中的成员属性
3. 对齐填充字节（Padding）：由于HotSpot虚拟机的自动内存管理系统要求对象的起始地址必须是8字节的整数倍，也就是对象的大小必须是8字节的整数倍。

Java对象头结构为：

1. Mark Word :用于存储对象自身的运行时数据， 如哈希码（HashCode）、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等
2. Klass Pointer ：对象指向它的类的元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例

那么我们本期先了解什么是对象头，对象头的结构又是如何的呢？
Java对象的对象头由 mark word 和 klass pointer 两部分组成，mark word存储了同步状态、标识、hashcode、GC状态等等。klass pointer存储对象的类型指针，该指针指向它的类元数据值得注意的是，如果应用的对象过多，使用64位的指针将浪费大量内存。64位的JVM比32位的JVM多耗费50%的内存。

1.1、Mark Word

这部分主要用来存储对象自身的运行时数据，如hashcode、gc分代年龄等。mark word的位长度为JVM的一个Word大小，也就是说32位JVM的Mark word为32位，64位JVM为64位。

enum {  
		 locked_value             = 0, // 0 00 轻量级锁
 		 unlocked_value           = 1, // 0 01 无锁
         monitor_value            = 2, // 0 10 重量级锁
         marked_value             = 3, // 0 11 gc标志
         biased_lock_pattern      = 5  // 1 01 偏向锁
  };

markword在不同的场景下会有不同的bit结构如下：

1. 在正常不加锁时，mark word 由lock、biased_lock、age、identity_hashcode组成，age是GC的年龄，最大15（4位），每从Survivor区复制一次，年龄增加1。identity_hashcode就是对象的哈希码，当对象处于加锁状态时，这个哈希码会移到monitor，（synchronized会在代码块前后插入monitor）。
2. 在偏向锁时，mark word 由lock、biased_lock、age、epoch、thread组成。epoch：偏向锁在CAS锁操作过程中，偏向性标识，表示对象更偏向哪个锁。thread：持有偏向锁的线程ID，如果该线程再次访问这个锁的代码块，可以直接访问。
3. 在轻量级锁时，mark word 由lock、ptr_to_lock_record组成。ptr_to_lock_record：指向栈中锁记录的指针。
4. 在重量级锁时，mark word 由lock、ptr_to_heavyweight_monitor组成。ptr_to_heavyweight_monitor：指向对象监视器Monitor的指针。

1.2、Klass Pointer

即对象指向它的元数据的指针，虚拟机通过这个指针来确定是哪个类的实例。并不是所有的虚拟机实现都必须在对象数据上保留类型指针(通过句柄池访问)。
Class对象的类型指针，JDK8默认开启指针压缩后为4字节，关闭指针压缩（-XX:-UseCompressedOops）后，长度为8字节。其指向的位置是对象对应的Class对象（其对应的元数据对象）的内存地址。

1. 句柄访问：会在堆中开辟一块内存作为句柄池，句柄中储存了对象实例数据（属性值结构体）的内存地址，访问类型数据的内存地址（类信息，方法类型信息），对象实例数据一般也在heap中开辟，类型数据一般储存在方法区中。reference存储的是稳定的句柄地址，对象移动也不会影响句柄的地址位置。
2. 指针访问：指针访问方式指reference中直接储存对象在heap中的内存地址，但对应的类型数据访问地址需要在实例中存储。节省了一次指针定位的开销。但是对象移动后需要改变reference的地址。

1.3、术语介绍

我们现在使用的64位 JVM会默认使用选项 +UseCompressedOops 开启指针压缩，将指针压缩至32位。

|--------------------------------------------------------------------------------------------------------------|
|                                              Object Header (128 bits)                                        |
|--------------------------------------------------------------------------------------------------------------|
|                        Mark Word (64 bits)                                    |      Klass Word (64 bits)    |       
|--------------------------------------------------------------------------------------------------------------|
|  unused:25 | identity_hashcode:31 | unused:1 | age:4 | biased_lock:1 | lock:2 |     OOP to metadata object   |  无锁
|----------------------------------------------------------------------|--------|------------------------------|
|  thread:54 |         epoch:2      | unused:1 | age:4 | biased_lock:1 | lock:2 |     OOP to metadata object   |  偏向锁
|----------------------------------------------------------------------|--------|------------------------------|
|                     ptr_to_lock_record:62                            | lock:2 |     OOP to metadata object   |  轻量锁
|----------------------------------------------------------------------|--------|------------------------------|
|                     ptr_to_heavyweight_monitor:62                    | lock:2 |     OOP to metadata object   |  重量锁
|----------------------------------------------------------------------|--------|------------------------------|
|                                                                      | lock:2 |     OOP to metadata object   |    GC
|--------------------------------------------------------------------------------------------------------------|

简单介绍一下各部分的含义
lock: 锁状态标记位，该标记的值不同，整个mark word表示的含义不同。
biased_lock：偏向锁标记，为1时表示对象启用偏向锁，为0时表示对象没有偏向锁。

age：Java GC标记位对象年龄。
identity_hashcode：对象标识Hash码，采用延迟加载技术。当对象使用HashCode()计算后，并会将结果写到该对象头中。当对象被锁定时，该值会移动到线程Monitor中。
thread：持有偏向锁的线程ID和其他信息。这个线程ID并不是JVM分配的线程ID号，和Java Thread中的ID是两个概念。
epoch：偏向时间戳。
ptr_to_lock_record：指向栈中锁记录的指针。
ptr_to_heavyweight_monitor：指向线程Monitor的指针。

2、对象头打印

2.1、工具依赖包

<dependency>
  <groupId>org.openjdk.jol</groupId>
  <artifactId>jol-core</artifactId>
  <version>0.8</version>
</dependency>

2.2、未加锁

package cn.wen.sync;

import org.openjdk.jol.info.ClassLayout;

public class A {

    boolean flag = false;

    public static void main(String[] args) {
        A a = new A();
        System.out.println(ClassLayout.parseInstance(a).toPrintable());
    }

}

输出的第一行内容和锁状态内容对应
unused:1 | age:4 | biased_lock:1 | lock:2
0 0000 0 01 代表A对象正处于无锁状态

第三行中表示的是被指针压缩为32位的klass pointer
第四行则是我们创建的A对象属性信息 1字节的boolean值
第五行则代表了对象的对齐字段 为了凑齐64位的对象，对齐字段占用了3个字节，24bit

2.3、偏向锁

package cn.wen.sync;

import org.openjdk.jol.info.ClassLayout;

/**
 * 对偏向锁的对象头进行查看
 */
public class BiasedLockDemo1 {

    public static void main(String[] args) {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        A a = new A();
        System.out.println(ClassLayout.parseInstance(a).toPrintable());
    }

}

输出结果：

因为 lock 01 为无锁状态 biased_lock 为 1 则为偏向锁
刚开始使用这段代码我是震惊的，为什么睡眠了5s中就把活生生的A对象由无锁状态改变成为偏向锁了呢？
JVM启动时会进行一系列的复杂活动，比如装载配置，系统类初始化等等。在这个过程中会使用大量synchronized关键字对对象加锁，且这些锁大多数都不是偏向锁。为了减少初始化时间，JVM默认延时加载偏向锁。这个延时的时间大概为4s左右，具体时间因机器而异。当然我们也可以设置JVM参数来取消延时加载偏向锁。

-XX:BiasedLockingStartupDelay=0

可能你又要问了，我这也没使用synchronized关键字呀，那不也应该是无锁么？怎么会是偏向锁呢？
仔细看一下偏向锁的组成，对照输出结果红色划线位置，你会发现占用 thread 和 epoch 的 位置的均为0，说明当前偏向锁并没有偏向任何线程。此时这个偏向锁正处于可偏向状态，准备好进行偏向了！你也可以理解为此时的偏向锁是一个特殊状态的无锁。

大家可以看下面这张图理解一下对象头的状态的创建过程

下面使用了synchronized 关键字的输出

public static void main(String[] args) throws InterruptedException {
    Thread.sleep(5000);
    A a = new A();
    synchronized (a){
        System.out.println(ClassLayout.parseInstance(a).toPrintable());
    }
}

thread 应该是线程的地址 当前偏向锁偏向了主线程。

2.4、轻量级锁

package cn.wen.sync;

import org.openjdk.jol.info.ClassLayout;

/**
 * 轻量级锁的展示
 */
public class CASLockDemo1 {

    public static void main(String[] args) throws Exception {
        Thread.sleep(5000);
        A a = new A();

        Thread thread1= new Thread(){
            @Override
            public void run() {
                synchronized (a){
                    System.out.println("thread1 locking");
                    System.out.println(ClassLayout.parseInstance(a).toPrintable()); // 偏向锁
                }
            }
        };
        thread1.start();
        thread1.join();
        Thread.sleep(10000);

        synchronized (a){
            System.out.println("main locking");
            System.out.println(ClassLayout.parseInstance(a).toPrintable());// 轻量锁
        }
    }
}

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

2.5、轻量级锁

public static void main(String[] args) throws InterruptedException {
    Thread.sleep(5000);
    A a = new A();
    Thread thread1 = new Thread(){
        @Override
        public void run() {
            synchronized (a){
                System.out.println("thread1 locking");
                System.out.println(ClassLayout.parseInstance(a).toPrintable());
                try {
                    // 让线程晚点儿死亡，造成锁的竞争
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    };
    Thread thread2 = new Thread(){
        @Override
        public void run() {
            synchronized (a){
                System.out.println("thread2 locking");
                System.out.println(ClassLayout.parseInstance(a).toPrintable());
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    };
    thread1.start();
    thread2.start();
}

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