并发编程-synchronized原理进阶

Java 对象头

普通对象:占8个字节
并发编程-synchronized原理进阶

数组对象:占12个字节
并发编程-synchronized原理进阶

Mark Word结构

32位虚拟机下:MarkWord有4个字节 最后2个bit位表示状态
并发编程-synchronized原理进阶

64位虚拟机下:MarkWord有8个字节 最后2个bit位表示状态
并发编程-synchronized原理进阶

状态 说明
01 无锁
00 轻量级锁
10 重量级锁
11 标记为GC清理

Monitor(锁)

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

Monitor 结构如下:
并发编程-synchronized原理进阶

  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
    并发编程-synchronized原理进阶

  2. 让锁记录中Object reference指向锁对象,并尝试用 cas 替换 Object 的 Mark Word,将 Mark Word 的值存入锁记录
    并发编程-synchronized原理进阶

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

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

    • 如果是其它线程已经持有了该 Object 的轻量级锁,这时表明有竞争,进入锁膨胀过程
    • 如果是自己执行了 synchronized 锁重入,那么再添加一条 Lock Record 作为重入的计数
      并发编程-synchronized原理进阶
  5. 当退出 synchronized 代码块(解锁时)如果有取值为 null 的锁记录,表示有重入,这时重置锁记录,表示重入计数减一
    并发编程-synchronized原理进阶

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

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

锁膨胀

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

static Object obj = new Object();

    public static void method1() {
        synchronized (obj) {
            // 同步块
        }
    }
  1. 当 Thread-1 进行轻量级加锁时,Thread-0 已经对该对象加了轻量级锁
    并发编程-synchronized原理进阶

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

    • 即为 Object 对象申请 Monitor 锁,让 Object 指向重量级锁地址
    • 然后自己进入 Monitor 的 EntryList BLOCKED
      并发编程-synchronized原理进阶
  3. 当 Thread-0 退出同步块解锁时,使用 cas 将 Mark Word 的值恢复给对象头,失败。这时会进入重量级解锁流程

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

自旋优化

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

自旋重试成功的情况
并发编程-synchronized原理进阶

自旋重试失败的情况
并发编程-synchronized原理进阶

注意:

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

偏向锁

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

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

并发编程-synchronized原理进阶
并发编程-synchronized原理进阶

偏向状态

并发编程-synchronized原理进阶
一个对象创建时:

  • 如果开启了偏向锁(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

上一篇:KingbaseES R6集群sys_monitor.sh change_password一键修改集群用户密码


下一篇:农历虎年快到了,我用 Python 写副春联恭祝大家幸福平安