多线程五 锁的膨胀过程

已于 2024-09-02 11:57:56 修改
阅读量266 收藏
点赞数
分类专栏： 多线程 文章标签： java 多线程 thread
于 2020-04-07 21:29:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28911061/article/details/105373016
版权

目录

1.偏向锁发生情况？

线程复用 

批量重偏向

批量撤销

2.轻量级锁什么时候发生的？

总结

上一篇中，主要是对加解锁，还有锁的分类有了一个了解：

1. 锁在对象中的表示（无锁：001  ，偏向锁：101 ，轻量级锁： 000，重量级锁：  010)

2. 锁分：偏向锁、轻量级锁、重量级锁

3. jvm在启动时会有大概4秒的延迟偏向，所以，一开始程序运行是无锁状态，可以通过run时加入参数修改这个值

4. 偏向锁偏向锁在计算hashCode后不能在偏向

5. 调用wait方法后，直接升级为重量级锁

6. 长时间获取不到锁会升级重量级锁

1.偏向锁发生情况？

    上一篇中，我们发现jvm的优化过程中，存在延迟偏向，我们通过让线程睡眠过了延迟时间之后，锁从一开始的轻量级锁变为偏向锁（也可以设置参数：-XX:+UseBiasedLocking -XX:BiasedLockingStartupDelay=0，将延迟时间设置为0，），来查看单线程对锁的作用。

再者可以这样理解：

在加锁的情况下，多个线程会竞争资源，但是在后续的程序运行中，几乎都是同一个线程获取锁，所以，为了避免加锁解锁的资源浪费，将锁偏向为一个线程，提高同步代码的性能。

线程复用 

还有一种情况：

-XX:+UseBiasedLocking -XX:BiasedLockingStartupDelay=0 

public static void main(String[] args) {
    TestA a = new TestA();
    Thread t1 = new Thread(){
        @Override
        public void run() {
            synchronized (a) {
                System.out.println("第一个线程。。。。");
                System.out.println(ClassLayout.parseInstance(a).toPrintable());
            }
        }
    };
    t1.start();

    try {
        t1.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    Thread t2 = new Thread(){
        @Override
        public void run() {
            synchronized (a) {
                System.out.println("第二个线程。。。。");
                System.out.println(ClassLayout.parseInstance(a).toPrintable());
            }
        }
    };
    t2.start();
}

看结果前，不妨猜测一下，线程t2是不是轻量级锁？

第一个线程。。。。
com.lry.thread.TestA object internals:
OFFSET  SIZE      TYPE DESCRIPTION                               VALUE
      0     4           (object header)                           05 b8 ab 1f (00000101 10111000 10101011 00011111) (531347461)
      4     4           (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4           (object header)                           05 c2 00 f8 (00000101 11000010 00000000 11111000) (-134168059)
     12     4       int TestA.b                                   0
     16     1   boolean TestA.a                                   false
     17     7           (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 7 bytes external = 7 bytes total


第二个线程。。。。
com.lry.thread.TestA object internals:
OFFSET  SIZE      TYPE DESCRIPTION                               VALUE
      0     4           (object header)                           05 b8 ab 1f (00000101 10111000 10101011 00011111) (531347461)
      4     4           (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4           (object header)                           05 c2 00 f8 (00000101 11000010 00000000 11111000) (-134168059)
     12     4       int TestA.b                                   0
     16     1   boolean TestA.a                                   false
     17     7           (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 7 bytes external = 7 bytes total

结果是两个都是偏向锁，首先他不存在资源竞争，交互获取，不看结果真不知道是偏向锁，而且两个线程中的线程ID(531347461 这里他不是确切的线程ID，但可以当做是)也是一样的，这里出现一个线程复用的问题，第一个线程被销毁后，第二个线程会拿到同样的ID，然后同步操作时会判断线程ID是否是一样，不一样就会升级为轻量级锁。（非官方，非权威，个人理解）

尝试在第二个线程前面增加一个线程：

new Thread(()->{
    try {
        Thread.sleep(20);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}).start();

结果很明显的从偏向锁变为轻量级锁了。

第一个线程。。。。
com.lry.thread.TestA object internals:
OFFSET  SIZE      TYPE DESCRIPTION                               VALUE
      0     4           (object header)                           05 78 c9 1f (00000101 01111000 11001001 00011111) (533297157)
      4     4           (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4           (object header)                           05 c2 00 f8 (00000101 11000010 00000000 11111000) (-134168059)
     12     4       int TestA.b                                   0
     16     1   boolean TestA.a                                   false
     17     7           (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 7 bytes external = 7 bytes total

第二个线程。。。。
com.lry.thread.TestA object internals:
OFFSET  SIZE      TYPE DESCRIPTION                               VALUE
      0     4           (object header)                           60 f6 7c 20 (01100000 11110110 01111100 00100000) (545060448)
      4     4           (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4           (object header)                           05 c2 00 f8 (00000101 11000010 00000000 11111000) (-134168059)
     12     4       int TestA.b                                   0
     16     1   boolean TestA.a                                   false
     17     7           (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 7 bytes external = 7 bytes total

批量重偏向

    当一个线程实例化多个对象并执行同步操作，后来另一个线程也对这些对象进行同步操作，进行了多次撤销偏向锁后，jvm会认为接下来的这些对象都需要批量重偏向，那么接下来的对象都是偏向锁；

    因为线程在同一个线程里执行相同的操作，并去对同一个对象进行操作，致使产生这样的结果。

这里可以这样设置：

当然我们可以通过-XX:BiasedLockingBulkRebiasThreshold 和 -XX:BiasedLockingBulkRevokeThreshold 来手动设置阈值

这里也存在上面偏向锁的问题，在第二个线程前增加一个线程去除线程复用，出现的结果才会是正常结果，那如果不加呢，出现的结果是概率性的，说不定某次你运行的时候，结果全部是偏向第一个线程，你会认为这就是重偏向，其实不对，你再多运行几次，就会发现，结果有很大的不同，jvm默认的批量重偏向阈值为20-40，那么正确结果是前19个，是轻量级锁，从第20个开始到40个结束，会是偏向锁。

  public static void main(String[] args) {
        List<TestA> list = new ArrayList<>();

        Thread t = new Thread(()->{
            for (int i = 0; i < 50; i++) {
                TestA a = new TestA();
                synchronized (a) {
                    list.add(a);
                    if (i == 49) {
                        System.out.println("第一个线程操作------");
                        System.out.println(ClassLayout.parseInstance(a).toPrintable());
                    }
                }
            }
        });

        t.start();
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
// 增加一个线程 ，去占用第一个线程，避免线程复用
        new Thread(()->{
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        System.out.println("第二个线程操作------------------");
        Thread t2 = new Thread(()->{
            for (int i = 0; i < list.size(); i++) {
                synchronized (list.get(i)) {
                    if(i == 18 || i == 19){
                        System.out.println("第二个线程  计数："+(i+1)+"-------------");
                        System.out.println(ClassLayout.parseInstance(list.get(i)).toPrintable());
                    }
                }
            }
        });
        t2.start();
    }

结果太长，就贴每个操作的第一次：

第一个线程操作------
com.lry.thread.TestA object internals:
OFFSET  SIZE      TYPE DESCRIPTION                               VALUE
      0     4           (object header)                           05 a8 25 20 (00000101 10101000 00100101 00100000) (539338757)
      4     4           (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4           (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     4       int TestA.b                                   0
     16     1   boolean TestA.a                                   false
     17     7           (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 7 bytes external = 7 bytes total

第二个线程操作------------------
第二个线程  计数：19-------------
com.lry.thread.TestA object internals:
OFFSET  SIZE      TYPE DESCRIPTION                               VALUE
      0     4           (object header)                           18 f4 cb 20 (00011000 11110100 11001011 00100000) (550237208)
      4     4           (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4           (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     4       int TestA.b                                   0
     16     1   boolean TestA.a                                   false
     17     7           (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 7 bytes external = 7 bytes total

第二个线程  计数：20-------------
com.lry.thread.TestA object internals:
OFFSET  SIZE      TYPE DESCRIPTION                               VALUE
      0     4           (object header)                           05 01 3b 20 (00000101 00000001 00111011 00100000) (540737797)
      4     4           (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4           (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     4       int TestA.b                                   0
     16     1   boolean TestA.a                                   false
     17     7           (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 7 bytes external = 7 bytes total

批量撤销

根据上面批量重偏向得到的结果来看，线程A对多个对象实例化同步，线程B对这些对象同步操作，但是如果线程B只对这些对象操作20个，出现批量偏向，然后后面的不进行同步操作，这时，线程C过来了，继续对这些对象同步，当超过批量撤销的阈值后，就会将所有的对象转为轻量锁。

这里结果没得到证明，留下问题，之后再来研究。

2.轻量级锁什么时候发生的？

  • 单个线程

  • 多个线程交替执行  

  • 多个线程互斥执行

    当一个线程去拿一个资源的时候，发现得不到资源，然后会先自旋一段时间，然后再去拿，如果再拿不到，那么就会膨胀，具体的自旋时间需要看jvm源码。

    可以这样理解：一个线程去拿一个不属于自己线程的资源时，就会膨胀（不是很准确）

public static void main(String[] args) {
        TestA a = new TestA();
long start = System.currentTimeMillis();
        new Thread(()->{
            synchronized (a) {
                System.out.println(Thread.currentThread().getName()+" running ");
                System.out.println(ClassLayout.parseInstance(a).toPrintable());
                System.out.println("线程执行时间："+(System.currentTimeMillis() - start ));
            }
        },"次线程").start();

        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        synchronized (a) {
            System.out.println(Thread.currentThread().getName()+" running ");
            System.out.println(ClassLayout.parseInstance(a).toPrintable());
        }
    }

可见，交替执行的线程是轻量级锁

次线程 running
com.lry.thread.TestA object internals:
OFFSET  SIZE      TYPE DESCRIPTION                               VALUE
      0     4           (object header)                           80 f6 58 20 (10000000 11110110 01011000 00100000) (542701184)
      4     4           (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4           (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     4       int TestA.b                                   0
     16     1   boolean TestA.a                                   false
     17     7           (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 7 bytes external = 7 bytes total

线程执行时间：3719
main running
com.lry.thread.TestA object internals:
OFFSET  SIZE      TYPE DESCRIPTION                               VALUE
      0     4           (object header)                           88 f1 9b 02 (10001000 11110001 10011011 00000010) (43774344)
      4     4           (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4           (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)
     12     4       int TestA.b                                   0
     16     1   boolean TestA.a                                   false
     17     7           (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 7 bytes external = 7 bytes total

如果在第一个线程修改如下，加锁后增加睡眠时间，分别设置2秒和5秒，

 new Thread(()->{
            synchronized (a) {
                System.out.println(Thread.currentThread().getName()+" running ");
                System.out.println(ClassLayout.parseInstance(a).toPrintable());
                try {
// 分别设置2秒和5秒
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程执行时间："+(System.currentTimeMillis() - start ));
            }
        },"次线程").start();

结果会发现：

设置两秒的时候，最后的对象是轻量级锁，因为避开了资源争夺，设置5秒的时候，第一个线程持有，并没有释放，导致第二个线程一直在申请锁，最后锁膨胀为重量级锁。

总结

偏向锁产生情况：

  1. 启动一段时间后；
  2. 单线程持有；
  3. 重偏向；
  4. 批量重偏向；

轻量级锁产生情况：

  1. 一开始启动那会是轻量级锁
  2. 互斥执行：线程A持有，线程B也想持有，但A持有中，B先自旋一段时间（这个时间jvm内部的，具体我不知道），拿到锁后，因为锁原本偏向A线程，这时被B拿走，就膨胀为轻量级锁，长时间拿不到就膨胀为重量级锁；
  3. 交替执行：线程A持有，线程B也想持有，但在A持有过程中，B没有去申请锁，在A释放后，B才去申请锁，这里存在重偏向问题，也不是真正的重偏向，及线程B会复用A的线程，在A B间再有一个线程可以避免复用；

重量级锁产生情况：

  1. 两个及两个以上竞争锁
  2. 调用wait方法后

用针戳左手中指指头
关注
专栏目录
JAVA锁的膨胀过程-分析-适合Java新手道架构师
10-19
锁膨胀过程其实就是无锁 → 偏向锁 → 轻量级锁 → 重量级锁的一个过程。在使用 synchronized 来同步代码块的时候，编译后，会在代码块的起始位置插入 monitorenter 指令，在结束或异常处插入 monitorexit 指令。当...
整理JVM锁膨胀机制
westlife_zhuang的博客
03-20 828
整理JVM锁膨胀机制JVM锁膨胀机制概述偏向锁轻量级锁重量级锁为什么要设计轻量级锁和偏向锁功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 JVM锁膨胀机制概述 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果
Synchronized锁膨胀机制
weixin_48680790的博客
03-30 691
前言 最近在读《深入理解JVM》，读到第13章 线程安全与锁优化中的轻量级锁与偏向锁时，总是难以理解，直到读到了这篇 死磕Synchronized底层实现–概论后，才恍然大悟，逐渐理解了书中的内容，特此来记录一下。 锁膨胀流程 被Synchronized修饰的方法/代码块，根据争抢线程的数量，时机不同，会经历以下的过程 #mermaid-svg-lTu2y1X3695EllPk {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16
线程学习（12）-锁膨胀
key_wu的博客
05-26 704
锁膨胀其实就是锁升级的过程，从偏离锁升级为轻量级锁，以及从轻量级锁升级成重量级锁的过程。这里以从轻量级锁升级成重量级锁的过程直接上代码吧。 轻量级锁升级成重量级锁的过程过程。 package com.bo.threadstudy.four; import lombok.extern.slf4j.Slf4j; import org.openjdk.jol.info.ClassLayout; import java.util.concurrent.locks.LockSupport; /** *
Java多线程之锁优化策略及锁膨胀
StackFlow的博客
03-06 2053
转载请注明原文地址：http://www.cnblogs.com/ygj0930/p/6561264.html     锁的优化策略    编码过程中可采取的锁优化的思路有以下几种：    1：减少锁持有时间          例如：对一个方法加锁，不如对方法中需要同步的几行代码加锁；    2：减小锁粒度        例如：ConcurrentHashMap采取对segment加锁而不是整个m...
JAVA锁的膨胀过程
weixin_34226706的博客
11-19 5679
为什么80%的码农都做不了架构师？>>> ...
synchronized锁原理分析（二、锁的膨胀过程）
12-21
本文将深入分析`synchronized`锁的膨胀过程，这个过程涉及到锁从无锁状态到轻量级锁，再到重量级锁的升级。 首先，我们需要理解Java对象头中的Mark Word，它是一个重要的数据结构，用于存储对象的锁状态和其他信息...
JAVA锁优化和膨胀过程.docx
11-14
在 HotSpot 虚拟机中，锁优化和膨胀过程是两个重要的技术，旨在提高多线程之间共享数据的效率和处理竞争问题。这些技术包括自适应自旋（Adaptive Spinning）、锁删除（Lock Elimination）、锁膨胀（Lock Coarsening...
JAVA锁的膨胀过程和优化.docx
11-14
本文将详细介绍Java锁的膨胀过程和优化策略。 首先，我们来看自旋锁。自旋锁是一种优化策略，当一个线程尝试获取已被其他线程持有的锁时，它并不会立即阻塞，而是会进行一次忙循环，持续检查锁是否已释放。如果持有...
Java锁升级的实现过程
08-19
Java 锁升级是 Java 中的一种同步机制，用于解决多线程并发访问共享资源的问题。 Java 锁升级的实现过程可以分为三个阶段：偏向锁、轻量级锁和重量级锁。 对象内存布局 在 Java 中，对象在内存中的布局可以分为三...
synchronized 锁升级(锁膨胀)机制 线程之间的爱恨纠葛
E的博客
04-27 657
synchronized 简介 synchronized是Java的关键字，可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。Java1.6之前是悲观锁也就是现在的重量级锁，开销非常大，1.6之后JVM引入了偏向锁和轻量级锁，采用了现在的锁升级机制，使得性能有了很大的提高。 相信大家多少在项目中也用到过这个关键字处理并发问题，今天话不多说...
多线程—锁膨胀
qq_42251944的博客
10-20 106
当线程0已经获取了Objec的轻量级锁，当线程1再获取时，就获取不到了，cas就会失败，此时就进入了锁膨胀过程。 （1）object对象会申请Monitor重量级锁，让Object记录重量级锁的地址。 （2）申请完之后，线程0时重量级锁（Monitor）的owner。 （3）线程1进入重量级锁（Monitor）的EntryList 阻塞（BLOCKED）。 当线程0的同步代码块执行完了之后，需要解锁时，需要按照重量级锁的解锁流程解锁了。 找到Monitor，设置Owner为null...
深入分析synchronized原理和锁膨胀过程(二)
weixin_34273481的博客
03-22 1003
前言 上一篇文章介绍了多线程的概念及synchronized的使用方法《synchronized的使用（一）》，但是仅仅会用还是不够的，只有了解其底层实现才能在开发过程中运筹帷幄，所以本篇探讨synchronized的实现原理及锁升级(膨胀)的过程。 synchronized实现原理 synchronized是依赖于JVM来实现同步的，在同步方法和代码块的原理有点区别。 同步代码块 我们在代码块...
锁膨胀（锁升级）总结
fubicheng208的博客
05-25 1192
1. 是什么？ 执行到synchronized关键字时，锁对象由偏向锁->轻量级锁->重量级锁的演化； 2. 各阶段 偏向锁：刚执行到Synchronized关键字时的锁对象为偏向锁（偏向第一个申请到它的线程）（通过CAS操作修改对象头里的锁标志位），当该线程执行完之后，锁不会被释放；当第二次执行到同步代码块时，线程会判断当前持有锁的线程是否就是自己（对象头里有持有锁的线程ID），若是则继续往下执行，不需要重新加锁；若不是，则会把偏向锁升级为轻量级锁。 轻量级锁: 当有第二个...
带你彻底搞懂锁膨胀，偏向锁，轻量级锁，重量级锁
weixin_42737868的博客
04-24 1517
1.synchronized 我们都知道synchronized内部有四种状态，分别是：无锁、偏向锁、轻量级锁和重量级锁，所以要搞懂这几种锁之间的变化我们得对synchronized有个大致的了解。 首先说一下synchronized在底层的实现，他是基于进入和退出Monitor对象（每一个对象都会有一个monitor与之关联）来实现方法同步和代码块同步的，对于方法同步官方并没有具体指出是如何实现...
synchronized 锁优化（二）：锁的状态及锁膨胀
To be a great coder
07-03 1427
本文中所提及的锁指的均是 JVM 提供的 synchronized. 在并发编程中，synchronized 一直被称为重量级锁，但是随着 JDK1.6 对 synchronized 进行了各种优化之后，有些情况下它就并不那么重了。本文将介绍从 JDK1.6 开始引入的新的锁状态的概念以及锁升级的过程（即所谓的锁膨胀）。   Java 对象头 在正式介绍之前，先要明确一下对象头这个概念。...
锁膨胀过程
搓搓那年时光静好
06-14 1555
如果在尝试加轻量级锁的过程中，CAS操作无法成功，这时一种情况就是有其他线程为此对象加上了轻量级锁(有竞争),这时候需要进行锁膨胀，将轻量级锁变为重量级锁。 static Object obj = new Object(); public static void method1(){ synchronized(obj){ // 同步块 } } 当Thread-1进行轻量级加锁时，Thread-0已经对该对象加了轻量级锁 这时Thread-1加轻量级锁失败，进入.
面试官问你Java偏向锁如何膨胀到重量级锁
07-08 189
点击上方“猿芯”，选择“设为星标”后台回复"1024"，有份惊喜送给面试的你Java对象头与Monitorjava对象头是实现synchronized的锁对象的基础，syn...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值