Java 对象头

普通对象：占8个字节

数组对象：占12个字节

Mark Word结构

32位虚拟机下：MarkWord有4个字节 最后2个bit位表示状态

64位虚拟机下：MarkWord有8个字节 最后2个bit位表示状态

Monitor(锁)

Monitor 被翻译为监视器或管程
每个 Java 对象都可以关联一个 Monitor 对象，如果使用synchronized给对象上锁（重量级）之后，该对象头的Mark Word 中就被设置指向 Monitor 对象的指针

Monitor 结构如下:

1. 刚开始 Monitor 中 Owner 为 null

2. 当 Thread-2 执行 synchronized(obj) 就会将 Monitor 的所有者 Owner 置为 Thread-2，Monitor中只能有一个 Owner

3. 在 Thread-2 上锁的过程中，如果 Thread-3，Thread-4，Thread-5 也来执行 synchronized(obj)，就会进入EntryList 进入BLOCKED状态

4. Thread-2 执行完同步代码块的内容，然后唤醒EntryList中等待的线程来竞争锁，竞争时是非公平的

5. 图中 WaitSet 中的 Thread-0，Thread-1 是之前获得过锁，但条件不满足进入 WAITING 状态的线程

注意：

synchronized 必须是进入同一个对象的 monitor 才有上述的效果
不加 synchronized 的对象不会关联监视器，不遵从以上规则

synchronized字节码

Code:
       0: getstatic     #2                # 拿到lock锁对象引用地址 后面关联Monitor
       3: dup                             # 复制一份lock信息
       4: astore_1                        # lock引用存入slot 1
       5: monitorenter                    # 将 lock对象 MarkWord 置为 Monitor 指针
       6: getstatic     #3                # Field counter:I
       9: iconst_1
      10: iadd
      11: putstatic     #3                // Field counter:I
      14: aload_1                         # 拿到之前存储的 lock引用
      15: monitorexit                     # 将 lock对象 MarkWord 重置（还原hashcode 分代年龄数据）, 唤醒 EntryList 
      16: goto          24    
      19: astore_2
      20: aload_1
      21: monitorexit                     # 将 lock对象 MarkWord 重置, 唤醒 EntryList
      22: aload_2
      23: athrow
      24: return
    Exception table:
       from    to  target type
           6    16    19   any
          19    22    19   any

16: goto 作用：
判断synchronized里面的代码是否发生异常 如果发生异常 根据Exception table信息 执行19行到22行的数据。保证了即使发生异常，锁资源也能正确被释放掉。

轻量级锁

轻量级锁的使用场景：如果一个对象虽然有多线程要加锁，但加锁的时间是错开的（也就是没有竞争），那么可以使用轻量级锁来优化。
轻量级锁对使用者是透明的，即语法仍然是 synchronized

static final Object obj = new Object();

    public static void method1() {
        synchronized (obj) {
            // 同步块 A
            method2();
        }
    }

    public static void method2() {
        synchronized (obj) {
            // 同步块 B
        }
    }

1. 创建锁记录（Lock Record）对象，每个线程都的栈帧都会包含一个锁记录的结构，内部可以存储锁定对象的Mark Word
   

2. 让锁记录中Object reference指向锁对象，并尝试用 cas 替换 Object 的 Mark Word，将 Mark Word 的值存入锁记录
   

3. 如果 cas 替换成功，对象头中存储了 锁记录地址和状态 00 ，表示由该线程给对象加锁，这时图示如下: 线程中的锁信息和锁对象中的Mark Word发生了替换
   

4. 如果 cas 失败，有两种情况

   • 如果是其它线程已经持有了该 Object 的轻量级锁，这时表明有竞争，进入锁膨胀过程
   • 如果是自己执行了 synchronized 锁重入，那么再添加一条 Lock Record 作为重入的计数
     

5. 当退出 synchronized 代码块（解锁时）如果有取值为 null 的锁记录，表示有重入，这时重置锁记录，表示重入计数减一
   

6. 当退出 synchronized 代码块（解锁时）锁记录的值不为 null，这时使用 cas 将 Mark Word 的值恢复给对象头

   • 成功，则解锁成功
   • 失败，说明轻量级锁进行了锁膨胀或已经升级为重量级锁，进入重量级锁解锁流程

锁膨胀

如果在尝试加轻量级锁的过程中，CAS 操作无法成功，这时一种情况就是有其它线程为此对象加上了轻量级锁（有竞争），这时需要进行锁膨胀，将轻量级锁变为重量级锁。

static Object obj = new Object();

    public static void method1() {
        synchronized (obj) {
            // 同步块
        }
    }

1. 当 Thread-1 进行轻量级加锁时，Thread-0 已经对该对象加了轻量级锁
   

2. 这时 Thread-1 加轻量级锁失败，进入锁膨胀流程

   • 即为 Object 对象申请 Monitor 锁，让 Object 指向重量级锁地址
   • 然后自己进入 Monitor 的 EntryList BLOCKED
     

3. 当 Thread-0 退出同步块解锁时，使用 cas 将 Mark Word 的值恢复给对象头，失败。这时会进入重量级解锁流程

   • 即按照 Monitor 地址找到 Monitor 对象，
   • 设置 Owner 为 null
   • 唤醒 EntryList 中 BLOCKED 线程

自旋优化

重量级锁竞争的时候，还可以使用自旋来进行优化，如果当前线程自旋成功（即这时候持锁线程已经退出了同步块，释放了锁），这时当前线程就可以避免阻塞。

自旋重试成功的情况

自旋重试失败的情况

注意：

自旋会占用 CPU 时间，单核 CPU 自旋就是浪费，多核 CPU 自旋才能发挥优势。
在 Java 6 之后自旋锁是自适应的，比如对象刚刚的一次自旋操作成功过，那么认为这次自旋成功的可能性会高，就多自旋几次；反之，就少自旋甚至不自旋，总之，比较智能。
Java 7 之后不能控制是否开启自旋功能

偏向锁

轻量级锁在没有竞争时（就自己这个线程），每次重入仍然需要执行 CAS 操作。

Java 6 中引入了偏向锁来做进一步优化：
只有第一次使用 CAS 将线程 ID 设置到对象的 Mark Word 头，之后发现这个线程 ID 是自己的就表示没有竞争，不用重新 CAS。以后只要不发生竞争，这个对象就归该线程所有

偏向状态

一个对象创建时：

• 如果开启了偏向锁（biased_lock : 默认开启），那么对象创建后，markword 值为 0x05 即最后 3 位为 101，这时它的thread、epoch(批量重偏向时使用)、age（分代年龄） 都为 0

• 偏向锁是默认是延迟的，不会在程序启动时立即生效，如果想避免延迟，可以加 VM 参数 - XX:BiasedLockingStartupDelay=0 来禁用延迟

• 如果没有开启偏向锁，那么对象创建后，markword 值为 0x01 即最后 3 位为 001，这时它的 hashcode、age 都为 0，第一次用到 hashcode 时才会赋值

撤销偏向状态

调用对象 hashCode

调用了对象的 hashCode，但偏向锁的对象 MarkWord 中存储的是线程 id，如果调用 hashCode 会导致偏向锁被撤销

• 轻量级锁会在锁记录中记录 hashCode
• 重量级锁会在 Monitor 中记录 hashCode

其它线程使用对象

当有其它线程使用偏向锁对象时，会将偏向锁升级为轻量级锁

调用 wait/notify

批量重偏向

如果对象虽然被多个线程访问，但没有竞争，这时偏向了线程 T1 的对象仍有机会重新偏向 T2，重偏向会重置对象的 Thread ID

当撤销偏向锁阈值超过 20 次后，jvm 会这样觉得，我是不是偏向错了呢，于是会在给这些对象加锁时重新偏向至加锁线程

批量撤销

当撤销偏向锁阈值超过 40 次后，jvm 会这样觉得，自己确实偏向错了，根本就不该偏向。于是整个类的所有对象都会变为不可偏向的，新建的对象也是不可偏向的

参考：
https://www.cnblogs.com/LemonFive/p/11246086.html
https://www.cnblogs.com/LemonFive/p/11248248.html

锁消除

static int x = 0;
    public void a() throws Exception {
        x++;
    }
    public void b() throws Exception {
        Object o = new Object();
        synchronized (o) {
            x++;
        }
    }

发现a方法和 b方法的运行时间没有什么区别 ， JIT（即时编译器）发现锁对象o 不会逃离临界区，就会默认消除这个锁
关闭锁消除优化参数： -XX:-EliminateLocks