synchronized锁升级就是这么的简单

最新推荐文章于 2025-04-08 20:26:17 发布

置顶三木加两木

最新推荐文章于 2025-04-08 20:26:17 发布

阅读量1k

点赞数 7

分类专栏： # Java并发编程文章标签： synchronized java 多线程并发

本文链接：https://blog.youkuaiyun.com/gongsenlin341/article/details/112244837

版权

Java并发编程专栏收录该内容

8 篇文章

订阅专栏

文章目录

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();
    }
}