JVM学习笔记之十（synchronized）

5. synchronized 优化

Java HotSpot 虚拟机中，每个对象都有对象头（包括 class 指针和 Mark Word）。Mark Word 平时存
储这个对象的 哈希码、分代年龄，当加锁时，这些信息就根据情况被替换为 标记位、线程锁记录指
针、重量级锁指针、线程ID 等内容

• 对象头存储内容图例，引用

|--------------------------------------------------------------------------------------------------------------|
|                                              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的指针。

5.1 轻量级锁

如果一个对象虽然有多线程访问，但多线程访问的时间是错开的（也就是没有竞争），那么可以使用轻 量级锁来优化。这就好比：

• 学生（线程A）用课本占座，上了半节课，出门了（CPU时间到），回来一看，发现课本没变，说明没 有竞争，继续上他的课。
• 如果这期间有其它学生（线程 B）来了，会告知（线程A）有并发访问，线程 A 随即升级为重量级锁，进入重量级锁的流程。
• 而重量级锁就不是那么用课本占座那么简单了，可以想象线程 A 走之前，把座位用一个铁栅栏围起来

假设有两个方法同步块，利用同一个对象加锁

public class Main3 {
    private static Object object = new Object();
    public static void main(String[] args) {
        synchronized (object) {
            // 同步代码块 A
            method();
        }
    }
    
    public static void method() {
        synchronized (object) {
            // 同步代码块 B
        }
    }
}

• 每个线程的栈帧都会包含一个锁记录的结构，内部都可以存储锁定对象的 Mark Word

线程1	对象 Mark Word	线程2
访问同步块 A，把 Mark 复制到线程 1 的锁记录	01（无锁）	-
CAS 修改 Mark 为线程 1 锁记录地址	01（无锁）	-
成功（加锁）	00（轻量锁）线程 1 锁记录地址	-
执行同步块 A	00（轻量锁）线程 1 锁记录地址	-
访问同步块 B，把 Mark 复制到线程 1 的锁记录	00（轻量锁）线程 1 锁记录地址	-
CAS 修改 Mark 为线程 1 锁记录地址	00（轻量锁）线程 1 锁记录地址	-
失败（发现是自己的锁）	00（轻量锁）线程 1 锁记录地址	-
锁重入	00（轻量锁）线程 1 锁记录地址	-
执行同步块 B	00（轻量锁）线程 1 锁记录地址	-
同步块 B 执行完毕	00（轻量锁）线程 1 锁记录地址	-
同步块 A 执行完毕	00（轻量锁）线程 1 锁记录地址	-
成功（解锁）	01（无锁）	-
-	01（无锁）	访问同步块 A，把 Mark 复制到线程 2 的锁记录
-	01（无锁）	CAS 修改 Mark 为线程 2 锁记录地址
-	00（轻量锁）线程 2 锁记录地址	成功（加锁）
-	…	…

5.2 锁膨胀

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

private static Object object = new Object();
    public static void method() {
        synchronized (object) {
            // 同步代码块 B
    }

5.3 重量级锁

重量级锁竞争的时候，还可以使用自旋来进行优化，如果当前线程自旋成功（即这时候持锁线程已经退出了同步块，释放了锁），这时当前线程就可以避免阻塞。
在 Java 6 之后自旋锁是自适应的，比如对象刚刚的一次自旋操作成功过，那么认为这次自旋成功的可能
性会高，就多自旋几次；反之，就少自旋甚至不自旋，总之，比较智能。

• 自旋会占用 CPU 时间，单核 CPU 自旋就是浪费，多核 CPU 自旋才能发挥作用
• 好比等红灯时汽车是不是熄火，不熄火相当于自旋（等待时间短了划算），熄火了相当于阻塞（等待时间长了划算）
• Java 7 之后不能控制是否开启自旋功能、

自旋重试成功情况：

线程 1 （cpu 1 上）	对象 Mark	线程 2 （cpu 2 上）
-	10（重量锁）	-
访问同步块，获取 monitor	10（重量锁）重量锁指针	-
成功（加锁）	10（重量锁）重量锁指针	-
执行同步块	10（重量锁）重量锁指针	-
执行同步块	10（重量锁）重量锁指针	访问同步块，获取 monitor
执行同步块	10（重量锁）重量锁指针	自旋重试
执行完毕	10（重量锁）重量锁指针	自旋重试
成功（解锁）	01（无锁）	自旋重试
-	10（重量锁）重量锁指针	成功（加锁）
-	10（重量锁）重量锁指针	执行同步块
-	…	…

自旋重试失败情况：

线程 1 （cpu 1 上）	对象 Mark	线程 2 （cpu 2 上）
-	10（重量锁）	-
访问同步块，获取 monitor	10（重量锁）重量锁指针	-
成功（加锁）	10（重量锁）重量锁指针	-
执行同步块	10（重量锁）重量锁指针	-
执行同步块	10（重量锁）重量锁指针	访问同步块，获取 monitor
执行同步块	10（重量锁）重量锁指针	自旋重试
执行同步块	10（重量锁）重量锁指针	自旋重试
执行同步块	10（重量锁）重量锁指针	自旋重试
执行同步块	10（重量锁）重量锁指针	阻塞
-	…	…

5.4 偏向锁

轻量级锁在没有竞争时（就自己这个线程），每次重入仍然需要执行 CAS 操作。Java 6 中引入了偏向锁来做进一步优化：只有第一次使用 CAS 将线程 ID 设置到对象的 Mark Word 头，之后发现这个线程 ID 是自己的就表示没有竞争，不用 CAS

• 撤销偏向需要将持锁线程升级为轻量级锁，这个过程中所有线程需要暂停（STW）
• 访问对象的 hashCode 也会撤销偏向锁
• 如果对象虽然被多个线程访问，但没有竞争，这时偏向了线程 T1 的对象仍有机会重新偏向 T2，
  重偏向会重置对象的 Thread ID
• 撤销偏向和重偏向都是批量进行的，以类为单位
  如果撤销偏向到达某个阈值，整个类的所有对象都会变为不可偏向的
• 可以主动使用 -XX:-UseBiasedLocking 禁用偏向锁

假设有两个 方法同步块，利用同一个对象加锁

public class Main3 {
    private static Object object = new Object();
    public static void main(String[] args) {
        synchronized (object) {
            // 同步代码块 A
            method();
        }
    }
    
    public static void method() {
        synchronized (object) {
            // 同步代码块 B
        }
    }
}

5.5 其他优化

5.5.1 减少上锁时间

• 同步代码块尽量短

5.5.2 减少锁的粒度

将一个锁拆分为多个锁提高并发度，例如：

• ConcurrenHashMap
• LongAddr 分为 base 和 cells 两部分。没有并发竞争用的时候或者时 cells 数组正在初始化的时候，回使用 CAS 来累加值到 base，有并发争用，会初始化 cells 数组，数组有多少个 cell，就允许多少个线程并行修改，最后将数组中的每个 cell 累加，再加上 base 就是最终的值
• LinkedBlockingQueue 入队和出队使用不同的锁，相对于 LinkedBlockingArray 只有一个锁效率要高

5.5.3 锁粗化

多次循环进入同步块不如同步块内多次循环 另外 JVM 可能会做如下优化，把多次 append 的加锁操作粗化为一次（因为都是对同一个对象加锁，没必要重入多次）

new StringBuffer().append("a").append("b").append("c");

5.5.4 锁消除

JVM 会进行代码的逃逸分析，例如某个加锁对象是方法内局部变量，不会被其它线程所访问到，这时候就会被即时编译器忽略掉所有同步操作。

5.5.5 读写分离

CopyOnWriteArrayList ConyOnWriteSet

参考：
https://wiki.openjdk.java.net/display/HotSpot/Synchronization

http://luojinping.com/2015/07/09/java锁优化/

https://www.infoq.cn/article/java-se-16-synchronized

https://www.jianshu.com/p/9932047a89be

https://www.cnblogs.com/sheeva/p/6366782.html

https://stackoverflow.com/questions/46312817/does-java-ever-rebias-an-individual-lock