栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

synchronized进阶

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

synchronized进阶

2.8 synchronized原理进阶 2.8.1 Monitor(管程)

概念:Moinitor被翻译为监视器或者管程,每一个创建的Java对象都关联着一个Monitor对象,如果使用synchronized给对象上锁(重量级),该对象头的Mark Word中就被设置了指向Monitor的指针

Java对象头(JVM会学)

32位

Klass Word (32 bits)存放数据类型

Mark Word (32 bits)存放头

普通对象

|--------------------------------------------------------------|
| Object Header (64 bits) |
|------------------------------------|-------------------------|
| Mark Word (32 bits) | Klass Word (32 bits) |
|------------------------------------|-------------------------|

数组对象

|---------------------------------------------------------------------------------|
| Object Header (96 bits) |
|--------------------------------|-----------------------|------------------------|
| Mark Word(32bits) | Klass Word(32bits) | array length(32bits) |
|--------------------------------|-----------------------|------------------------|

Mark Word (32 bits)

2.8.2 锁的执行流程

一个对象对应一个Monitor

锁的执行流程

注意事项:

  1. synchronized 必须进入同一个Moinitor对象才会执行上述流程
  2. 不加synchronized的对象不会关联管程,不遵从上述流程
2.8.3轻量级锁

使用场景:多个线程访问,但是访问时间岔开(没有竞争)

区别:轻量级锁Object不会申请Monitor锁

步骤

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

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

  1. 如果 cas 替换成功,对象头中存储了 锁记录地址和状态 00(没有锁是01,00代表轻量级锁) ,表示由该线程给对象加锁,这时图示如下

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

    1. 已经有别的线程替换过了,持有了轻量级锁,表明有竞争了,进入锁膨胀

    2. 如果是自己线程又执行了 synchronized锁重入,那么再添加一条 Lock Record 作为重入的计数

      synchronized(Object){
      	synchronized(Object){
              //这其实是有点脱裤子放屁的感觉,但是难免会写出这样的代码
              //当退出 synchronized 代码块(解锁时)如果有取值为 null 的锁记录,表示有重入,这时重置锁记录,表示重入计数减一
              //当退出 synchronized 代码块(解锁时)锁记录的值不为 null,这时使用 cas 将 Mark Word 的值恢复给对象头
              	 1.成功,则解锁成功
                   2.失败,说明轻量级锁进行了锁膨胀或已经升级为重量级锁,进入重量级锁解锁流程
      
          }
      }
      

2.8.4锁膨胀

场景

已知,轻量级锁只能用于多线程时各个线程利用时间不冲突,当冲突发生时(一个线程已经加了轻量级锁,另一个还线程还想进行CAS操作),证明轻量级锁在这个场景不合适,这时就需要进行锁膨胀,将轻量级锁变为重量级锁

步骤:

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

  1. 这时 Thread-1 加轻量级锁失败,进入锁膨胀流程
    • 即为 Object 对象申请 Monitor 锁,让 Object 指向重量级锁地址
    • 然后自己(这里指的是后来的线程)进入 Monitor 的 EntryList BLOCKED
  2. 当 Thread-0 退出同步块解锁时,使用 cas 将 Mark Word 的值恢复给对象头,失败。这时会进入重量级解锁流程,即按照 Monitor 地址找到 Monitor 对象,设置 Owner 为 null,唤醒 EntryList 中 BLOCKED 线程
2.8.4 自旋优化

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

即:当线程1请求访问同步代码块遇到别的线程已经获得锁对象时(monitor里面的Markdown状态码被修改),线程1不会立刻进入阻塞状态,而是会重复执行几次看能否获得锁对象,可以就继续执行了,如果失败会进入阻塞状态.

  • 自旋会占用CPU时间,单核CPU自旋有点浪费,多核CPU自旋可以提高效率
  • java6后自旋就是自适应的,如果该对象自旋成功率高就多自旋,成功率第九少自旋甚至不自旋
  • java7后不能控制是否自旋
  1. 自旋成功情况

  1. 自旋失败

2.8.5偏向锁

场景:大家觉得轻量级锁虽然已经很简单了(较重量级锁取消了申请Mointor锁),但是还是有改进的地方

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

一个对象创建时:

  • 如果开启了偏向锁(默认开启),那么对象创建后,markword 值为 0x05 即最后 3 位为 101,这时它的 thread、epoch、age 都为 0

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

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

    class Dog {
        // 添加虚拟机参数 -XX:BiasedLockingStartupDelay=0 
        public static void main(String[] args) throws IOException {
            Dog d = new Dog();
            ClassLayout classLayout = ClassLayout.parseInstance(d);
    
            new Thread(() -> {
                log.debug("synchronized 前");
                System.out.println(classLayout.toPrintableSimple(true));
                synchronized (d) {
                    log.debug("synchronized 中");
                    System.out.println(classLayout.toPrintableSimple(true));
                }
                log.debug("synchronized 后");
                System.out.println(classLayout.toPrintableSimple(true));
            }, "t1").start();
    
        }
    }
    ==================
    输出
    11:08:58.117 c.TestBiased [t1] - synchronized 前 
    00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000101 
    11:08:58.121 c.TestBiased [t1] - synchronized 中 
    00000000 00000000 00000000 00000000 00011111 11101011 11010000 00000101 
    11:08:58.121 c.TestBiased [t1] - synchronized 后 
    00000000 00000000 00000000 00000000 00011111 11101011 11010000 00000101 
    

    **注:**处于偏向锁的对象解锁后,线程 id 仍存储于对象头中

偏向锁的撤销

  1. 调用了对象的 hashCode,但偏向锁的对象 MarkWord 中存储的是线程 id,如果调用 hashCode 会导致偏向锁被撤销
    • 轻量级锁会在锁记录中记录 hashCode
    • 重量级锁会在 Monitor 中记录 hashCode
    • 在调用 hashCode 后使用偏向锁,记得去掉 -XX:-UseBiasedLocking
  2. 其它线程使用对象
    • 当有其它线程使用偏向锁对象时,会将偏向锁升级为轻量级锁
  3. 调用 wait/notify
  4. 批量重偏向
    • 如果对象虽然被多个线程访问,但没有竞争,这时偏向了线程 T1 的对象仍有机会重新偏向 T2,重偏向会重置对象
      的 Thread ID
    • 当撤销偏向锁阈值超过 20 次后,jvm 会这样觉得,我是不是偏向错了呢,于是会在给这些对象加锁时重新偏向至
      加锁线程
  5. 批量撤销
    • 当撤销偏向锁阈值超过 40 次后,jvm 会这样觉得,自己确实偏向错了,根本就不该偏向。于是整个类的所有对象
      都会变为不可偏向的,新建的对象也是不可偏向的
2.8.6锁消除

当JVM发现不存在多线程时会自动取消锁机制,正常访问

2.8.7 锁粗化

相同对象多次加锁,导致线程发生多次重入,可以使用锁粗化方式来优化,这不同于之前讲的细分锁的粒度

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/963776.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号