synchronized锁升级就是这么的简单

最新推荐文章于 2024-05-07 13:39:29 发布
置顶 最新推荐文章于 2024-05-07 13:39:29 发布
阅读量967 收藏 14
点赞数 7
分类专栏： # Java并发编程 文章标签： synchronized java 多线程 并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gongsenlin341/article/details/112244837
版权

文章目录

1. 概述

在jdk1.6之后，对synchronized进行了优化，对于一个锁对象有如下6种状态：

非锁不可偏向状态、非锁可偏向状态、偏向锁状态、轻量级锁状态、重量级锁状态和GC状态。

本篇博客将介绍6种状态的区别以及synchronized的升级膨胀的一个过程。

2. Mark Word

在说明6种状态的不同之前，先来了解一下什么是Mark Word，Mark Word中所记录的信息包含了锁对象的6种状态。

一个对象在java堆当中由3部分组成：对象头，对象属性，对齐填充。其中对齐填充不是必须有的，是为了保证整个对象的大小是8字节的倍数。

在这里插入图片描述

对象头又是由两部分组成的，一部分是Mark Word，另一部分是一个指针指向方法区（元空间）中的类元信息，也就是表明这个对象属于哪个类。

Mark Word这里我们探讨的是64位的情况

下面先来看看这6种状态，在Mark Word当中是如何表示的：

  • 非锁不可偏向状态

    在这里插入图片描述

前25位不使用；后31位用于记录对象的hashcode，但是仅有当调用对象的hashcode()方法的时候，才会去计算hashcode 并在mark word中有记录，否则为0；后1位不使用；再后4位记录对象的年龄；倒数第三位表示是否可偏向，这里是无锁不可偏向状态，所以这一位为0，最后两位表示当前对象的状态，此时是01。

所以最后三位是001的情况下 是无锁不可偏向状态。

  • 非锁可偏向状态

    在这里插入图片描述

和上面差不多，只是倒数第三位上不同，可偏向状态，所以这一位是1，最后两位和上面相同。

  • 偏向锁状态

    在这里插入图片描述

前54位记录持有这个偏向锁的线程id，后两位记录偏向的时间戳，剩余部分和上面的相同。所以根据mark word来看这个锁是不是偏向锁要看三个部分。第一是看倒数第三位，是否可偏向，是1的话表示可偏向，再看最后两位 如果是01的话，此时可能是偏向锁。再看最前面54位，如果记录的是一个线程的id，那么这个对象就是一个偏向锁。

  • 轻量级锁状态

    在这里插入图片描述

前62位记录了某个线程栈中的锁记录的地址，后面再来说这个锁记录记录了些什么信息。最后两位是00，表示轻量级锁。

  • 重量级锁状态

    在这里插入图片描述

前62位记录了堆中一个monitor对象的地址，最后两位是10，表示重量级锁。

  • GC状态

    在这里插入图片描述

最后两位记录的是11，表示该对象将在下一次垃圾回收的时候被处理掉。

3. 非锁不可偏向状态与非锁可偏向状态的区别

首先是非锁，说明这两种状态下，当前对象还不是一个锁，仅仅是一个普通的对象而已。

不同点就在于一个是不可偏向状态，另一个是可偏向状态。

可偏向状态很好理解，就是当这个对象作为一个锁，被一个线程所持有的时候，这个对象会变成一个偏向锁的状态。

那么为什么会有一个不可偏向状态呢？

因为运行java程序启动虚拟机的时候，JVM内部的代码也有很多地方用到了synchronized，如果还需要从偏向状态再逐步的升级，那么是没有必要的。所以JVM设置了一个偏向锁的启动延迟，相关的JVM参数是-XX:BiasedLockingStartupDelay=4000，可以设置成0，表示取消启动延迟。

启动延迟表示在这个时间还没到的时候，所创建出来的对象，就不让他有机会从偏向锁的状态开始升级，而是直接从轻量级锁的状态开始。

下面是代码证明：

//代码1
@Slf4j(topic = "s")
public class TestSync {

    static Object lock = new Object();

    public static void main(String[] args){
        Lock lock = new Lock();
        ClassLayout classLayout = ClassLayout.parseInstance(lock);
        log.debug(classLayout.toPrintable());
    }
}
//代码2
@Slf4j(topic = "s")
public class TestSync {

    static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
      	TimeUnit.SECONDS.sleep(4);
        Lock lock = new Lock();
        ClassLayout classLayout = ClassLayout.parseInstance(lock);
        log.debug(classLayout.toPrintable());
    }
}

上面两段代码，区别在于，第二段代码再对象创建之前先延迟了4秒钟。输出结果分别如下：

代码1的结果：

在这里插入图片描述

代码2的结果：

在这里插入图片描述

看到这个结果肯定会很疑惑，不是说前25位没有使用吗。其实这是因为操作系统大小端存储的问题，本机操作系统采用的是小端存储，是指一个数据的低位字节序内容存放在低地址处，高位字节序的内容存放在高地址处。不太明白的可以看看这篇博客《大小端（数据在内存中的存储）》

从结果上可以看到，没有加延迟的代码，创建出来的对象是非锁不可偏向状态，而加了延迟4秒的代码，创建出来的对象是非锁可偏向状态。

4. 偏向锁

一个锁对象，仅有一个线程在获取它的时候，会使用cas来设置mark word持有这个锁的线程的id，此时这个锁就是偏向锁。之后该线程在进入和退出同步块的时候，不需要进行cas操作来加锁和解锁，只需要检查一下这个对象头中的mark word里是否存储着当前线程的id即可。

代码证明：

@Slf4j(topic = "s")
public class TestSync {

    static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {

        TimeUnit.SECONDS.sleep(4);
        Lock lock = new Lock();
        ClassLayout classLayout = ClassLayout.parseInstance(lock);
        log.debug(classLayout.toPrintable());

        new Thread(()->{
            synchronized (lock){
                log.debug("------------偏向锁 第一次------------");
                ClassLayout c = ClassLayout.parseInstance(lock);
                log.debug(c.toPrintable());
            }
            synchronized (lock){
                log.debug("------------偏向锁 第二次------------");
                ClassLayout c = ClassLayout.parseInstance(lock);
                log.debug(c.toPrintable());
            }
          	synchronized (lock){
                log.debug("------------偏向锁 第三次------------");
                ClassLayout c = ClassLayout.parseInstance(lock);
                log.debug(c.toPrintable());
            }
        },"t1").start();
}

运行的结果如下：

关注输出结果的当中划横线的三位就可以看出当前锁的状态

一开始末位3位101 表示 非锁可偏向状态。当线程t1第一次尝试获得锁的时候，mark word中的前54位就记录了 当前线程的id = 0x7fad098a，此时的锁就成了偏向锁。之后第二次第三次获得锁，可以看到 mark word中记录的信息没变 此时锁还是偏向锁。

在这里插入图片描述
另一种情况
当有多个线程交替获得锁的时候
一个线程尝试拿锁，发现当前锁记录id是另一个线程，那么就会判断该线程是否存活，如果该线程已经不存在了，那么此时不会锁升级，仅仅CAS替换偏向锁当中的线程id。
代码证明如下：

@Slf4j(topic = "s")
public static void main(String[] args) throws InterruptedException {
        Thread.sleep(5000);
        Object lock = new Object();

        Thread thread = new Thread(() -> {
            synchronized (lock) {
                ClassLayout classLayout = ClassLayout.parseInstance(lock);
                log.debug(classLayout.toPrintable());
            }
        });
        thread.start();
        Thread.sleep(2000);

        new Thread(()->{
            synchronized (lock) {
                ClassLayout classLayout = ClassLayout.parseInstance(lock);
                log.debug(classLayout.toPrintable());
            }
        }).start();
    }

运行结果如下：
在这里插入图片描述
此时两个线程拿到的锁都是偏向锁。

5. 轻量级锁

多个线程先后交替的去获得锁，此时不存在同时抢锁，锁记录的线程id对应的线程1还存活着，那么对象锁会从偏向锁转变成轻量级锁，此时会暂停锁记录中线程id对应的线程1，设置锁标志位为00(变为轻量级锁),偏向标记设置为0，将mark word复制到线程栈中的锁记录当中，更新mark word，将mark word指向线程1中锁记录。然后继续执行线程1的代码。

另一个线程就需要自旋等待线程1把锁释放掉。

一个线程释放锁的时候，使用cas将锁记录当中的mark word 替换回对象头当中。

自旋一定次数内拿到的锁都是轻量级锁。

代码证明：

@Slf4j(topic = "s")
public class TestSync {

    static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {

        TimeUnit.SECONDS.sleep(4);

        Lock lock = new Lock();
        ClassLayout classLayout = ClassLayout.parseInstance(lock);
        log.debug(classLayout.toPrintable());
      
        new Thread(()->{
            synchronized (lock){
                log.debug("------------偏向锁 第一次------------");
                ClassLayout c = ClassLayout.parseInstance(lock);
                log.debug(c.toPrintable());
            }
        },"t1").start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            synchronized (lock){
                log.debug("------------轻量级锁------------");
                ClassLayout c = ClassLayout.parseInstance(lock);
                log.debug(c.toPrintable());
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            log.debug("锁释放了之后");
            ClassLayout c = ClassLayout.parseInstance(lock);
            log.debug(c.toPrintable());
        },"t2").start();
    }
}

运行的结果如下：

一开始是非锁可偏向状态，当t1线程获得锁的时候，锁对象变成了偏向锁的状态

当t2线程也来拿锁的时候，锁对象升级成了轻量级锁的状态。

t2将锁释放了之后，锁对象成了非锁不可偏向状态，说明之后再有线程获得锁，也是从轻量级锁的状态开始。

在这里插入图片描述

6. 重量级锁

也是发生在多个线程拿锁的时候，

在上面一节中第二种情况，第二个线程自旋的次数超过阈值的时候，此时的锁就会变成重量级的锁。重量级锁中的指针的不再指向是线程栈中的锁记录，而是指向一个堆中的monitor对象。这个monitor对象会记录当前持有锁的线程。

代码证明：

@Slf4j(topic = "s")
public class TestSync {

    static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {

        TimeUnit.SECONDS.sleep(4);

        Lock lock = new Lock();
        ClassLayout classLayout = ClassLayout.parseInstance(lock);
        log.debug(classLayout.toPrintable());

        new Thread(()->{
            synchronized (lock){
                log.debug("------------偏向锁 第一次------------");
                ClassLayout c = ClassLayout.parseInstance(lock);
                log.debug(c.toPrintable());
            }
        },"t1").start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            synchronized (lock){
                log.debug("------------轻量级锁------------");
                ClassLayout c = ClassLayout.parseInstance(lock);
                log.debug(c.toPrintable());

                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                new Thread(()->{
                    synchronized (lock) {
                        log.debug("------------重量级锁------------");
                        ClassLayout c2 = ClassLayout.parseInstance(lock);
                        log.debug(c2.toPrintable());
                    }
                },"t3").start();

                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"t2").start();
    }
}

运行结果如下：

前面的就不说了，t2 线程获得了锁之后，在内部又创建了一个t3 线程，t3线程也要去拿锁，此时t3线程拿不到锁，会先进行自旋，超过了阈值之后，锁就成了重量级的锁了，t3会进入阻塞队列。等到t2线程把锁释放掉，t3被唤醒再继续执行。

在这里插入图片描述

7. synchronized锁升级总结

  • JVM 4秒默认的偏向锁启动延迟
  • 若不考虑偏向锁的启动延迟，当仅有一个线程拿锁的时候，锁对象的状态是偏向锁状态
  • 当多个线程拿锁的时候，若是交替拿锁不发生竞争或者发生竞争线程自旋的次数小于某阈值，偏向锁升级成轻量级锁。
  • 当自旋的次数超过某阈值，轻量级锁升级成重量级锁
三木加两木
关注
  • 7
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
专栏目录
java synchronized用法详解
09-01
5. **锁升级与性能** Java的`synchronized`在早期版本中性能较低，但随着JVM优化，现在它支持锁的升级，如从偏向锁到轻量级锁再到重量级锁，以适应不同场景，提高并发效率。 6. **死锁与活锁** 使用`synchronized...
自己动手写一把可重入锁测试案例
11-14
6. **锁升级与降级**：在某些情况下，我们可能需要将可重入锁升级为读写锁，以支持多个线程同时读取资源。这涉及到更复杂的设计，但原理类似。 7. **中断处理**：支持锁的中断，当线程在等待锁时，如果被中断，应该...
synchronized锁升级详细过程
weixin_71921932的博客
06-25 9267
synchronized锁升级详细过程
30分钟彻底弄懂 synchronized 锁升级过程
a1405的专栏
07-31 6208
些线程安全问题，这里面可能会产生一些预想不到的问题，所以下边我整理了一系列关于JDK中锁的问题，帮助大家更加深入地了解它们。
Java并发编程: Synchronized原理与锁升级
最新发布
玉汝于成
05-07 341
由上图分析可知刚new出来的对象处于无锁状态，当使用synchronized关键字后处于轻量级锁状态。
全网最全synchronized锁升级过程
小王博客基地
11-14 1192
在面试题中经常会有这么一道面试题，谈一下synchronized锁升级过程？之前背了一些，很多文章也说了，到底怎么什么条件才会触发升级，一直不太明白。实践是检验真理的唯一标准，今天就和大家一起实践一下，什么条件才会升级！经过实战，我们知道了每一个的切换条件，可以在面试中好好的回答了。不至于面试官反问一下就不坚定了！关于切换到重量级锁后，有兴趣的话，可以下载openJDK源码去看一下关于和源码下载地址：是 OpenJDK 中实现 Java同步机制的核心部分，它负责管理对象监视器。
Synchronized与锁升级
qq_45996900的博客
10-23 3173
锁升级以后，hashcode去哪了？锁升级为轻量级或重量级锁后，Mark Word中保存的分别是线程栈帧里的锁记录指针和重量级锁指针，已经没有位置再保存哈希码，GC年龄了，那么这些信息被移动到哪里去了呢？用书中的一段话来描述 锁和hashcode 之前的关系：在Java语言里面一个对象如果计算过哈希码，就应该一直保持该值不变(强烈推荐但不强制，因为用户可以重载hashCodc0方法按自己的意愿返回哈希码），否则很多依赖对象哈希码的API都可能存在出错风险。
synchronized 之锁升级
qq_38016945的博客
03-13 204
在实际应用中，大多数时候锁总是同一个线程持有很少发生竞争，也就是说锁总是被第一个占用它的线程持有，这个线程就是锁的偏向线程，如果在接下来的运行过程中，该锁没有被其他线程访问，那么持有偏向锁的线程将不会触发同步，只需在第一次被拥有的时候记录下偏向线程的id。如果有其他线程因为多次自旋导致轻量级锁升级为重量级锁那么CAS会失败，此时会释放锁并唤醒阻塞的线程。偏向锁撤销：偏向锁只有当其他线程竞争锁时，持有偏向锁的线程才会被撤销，撤销需要等待全局安全点，同时检查持有偏向锁的线程是否还在执行。
java锁机制详解.pdf
10-04
Java锁机制是多线程编程中...总结，Java锁机制提供了多种方式来控制并发访问，从简单的synchronized关键字到复杂的显式锁，帮助开发者实现线程安全的代码。理解并熟练运用这些机制，是编写高效、稳定多线程程序的关键。
组合锁
02-21
`ReentrantLock`是可重入的互斥锁，提供了与`synchronized`关键字类似的功能，但更灵活且具有更多高级特性。`ReadWriteLock`则提供了读写锁，允许多个读取者同时访问，但只允许一个写入者，这样可以提高并发性能。 ...
偏向锁-轻量级锁-重量级锁
04-14
当轻量级锁升级为重量级锁时，会阻塞后来的线程，直到持有锁的线程释放锁。这种锁的开销主要在于线程上下文切换，对于高并发的场景，这将大大降低程序的运行效率。 JVM会根据运行环境动态调整这三种锁的使用策略，...
synchronized锁升级过程
liang8999的博客
03-19 2370
synchronized 上锁，其实锁信息是加在对象头中的 markdown，对象中的前四个字节表示markdown；的方式，尽可能的把自身的LR设置到 markdown中，若设置成功，makrdown会有。有多个线程竞争synchronized锁时，先把偏向锁撤销，通过自旋的竞争（自旋锁）升级。不一定，偏向锁只有在单线程环境中效率最高；偏向锁每重入一次，在线程栈中都会生成一个LR，但这个LR的值等于NULL，重入次数。轻量级锁重入次数与偏向锁差不多，锁重入次数都是记录在线程栈的LR重，每重入一次也是。
多线程JUC 第2季 synchronized锁升级过程
健康平安的活着的专栏
09-13 175
1.结构： 前两行为8字节；后一行为类型指针4字节。2.读取流程3.结论：无锁状态，一个对象被实例化后，如果还没有被任何线程竞争锁，那么它为无锁状态(001)三 偏向锁3.1。
【Java多线程】面试常考——锁策略、synchronized的锁升级优化过程以及CAS（Compare and swap）
Hacynn的博客
02-27 1274
文章总结了面试中有关多线程的考点，主要涉及锁的策略、synchronized中锁的升级，锁消除，锁粗化的过程以及CAS（Compare and swap）比较并交换，并引申出CAS的ABA问题，以及对应的解决方案。
Java并发之synchronized详解
个人博客，欢迎收藏。https://xiaoaozz.github.io/
02-04 1075
带你详细学习Java中的synchronized关键字，包括原理与使用。
Synchronized锁升级
Shenandoah7的博客
03-02 960
于是引入了偏向锁，偏向锁在获取资源的时候会在资源对象上记录该对象是偏向该线程的，偏向锁并不会主动释放，这样每次偏向锁进入的时候都会判断该资源是否是偏向自己的，如果是偏向自己的则不需要进行额外的操作，直接可以进入同步操作。在1.6之前，锁都是重量级锁，即我们不管什么线程来操作资源，都要进行加锁释放锁，如果有多线程，还要等待之类的，很浪费资源，1.6之后引入了偏向锁与轻量锁来减小获取和释放锁所带来的性能消耗。当两个或以上线程交替获取锁，但并没有在对象上并发的获取锁时，偏向锁升级为轻量级锁。
synchronized锁的升级过程
天瑕的博客
07-15 5790
synchronized锁的升级过程
synchronized 锁升级
08-18
对于Java中的synchronized锁升级，有两个重要的概念：偏向锁和轻量级锁。 1. 偏向锁（Biased Locking）：当一个线程访问同步块时，会尝试获取锁。如果锁是无争用的（没有其他线程竞争），那么当前线程会将锁的标记...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值