synchronized锁升级就是这么的简单

1. 概述

在jdk1.6之后&＃xff0c;对synchronized进行了优化&＃xff0c;对于一个锁对象有如下6种状态&＃xff1a;

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

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

2. Mark Word

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

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

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

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

下面先来看看这6种状态&＃xff0c;在Mark Word当中是如何表示的&＃xff1a;

• 非锁不可偏向状态

  

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

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

• 非锁可偏向状态

  

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

• 偏向锁状态

  

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

• 轻量级锁状态

  

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

• 重量级锁状态

  

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

• GC状态

  

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

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

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

不同点就在于一个是不可偏向状态&＃xff0c;另一个是可偏向状态。

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

那么为什么会有一个不可偏向状态呢&＃xff1f;

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

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

下面是代码证明&＃xff1a;

//代码1
&＃64;Slf4j(topic &＃61; "s")
public class TestSync {static Object lock &＃61; new Object();public static void main(String[] args){Lock lock &＃61; new Lock();ClassLayout classLayout &＃61; ClassLayout.parseInstance(lock);log.debug(classLayout.toPrintable());}
}
//代码2
&＃64;Slf4j(topic &＃61; "s")
public class TestSync {static Object lock &＃61; new Object();public static void main(String[] args) throws InterruptedException {TimeUnit.SECONDS.sleep(4);Lock lock &＃61; new Lock();ClassLayout classLayout &＃61; ClassLayout.parseInstance(lock);log.debug(classLayout.toPrintable());}
}


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

代码1的结果&＃xff1a;

代码2的结果&＃xff1a;

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

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

4. 偏向锁

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

代码证明&＃xff1a;

&＃64;Slf4j(topic &＃61; "s")
public class TestSync {static Object lock &＃61; new Object();public static void main(String[] args) throws InterruptedException {TimeUnit.SECONDS.sleep(4);Lock lock &＃61; new Lock();ClassLayout classLayout &＃61; ClassLayout.parseInstance(lock);log.debug(classLayout.toPrintable());new Thread(()->{synchronized (lock){log.debug("------------偏向锁 第一次------------");ClassLayout c &＃61; ClassLayout.parseInstance(lock);log.debug(c.toPrintable());}synchronized (lock){log.debug("------------偏向锁 第二次------------");ClassLayout c &＃61; ClassLayout.parseInstance(lock);log.debug(c.toPrintable());}synchronized (lock){log.debug("------------偏向锁 第三次------------");ClassLayout c &＃61; ClassLayout.parseInstance(lock);log.debug(c.toPrintable());}},"t1").start();
}


运行的结果如下&＃xff1a;

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

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

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

&＃64;Slf4j(topic &＃61; "s")
public static void main(String[] args) throws InterruptedException {Thread.sleep(5000);Object lock &＃61; new Object();Thread thread &＃61; new Thread(() -> {synchronized (lock) {ClassLayout classLayout &＃61; ClassLayout.parseInstance(lock);log.debug(classLayout.toPrintable());}});thread.start();Thread.sleep(2000);new Thread(()->{synchronized (lock) {ClassLayout classLayout &＃61; ClassLayout.parseInstance(lock);log.debug(classLayout.toPrintable());}}).start();}


运行结果如下&＃xff1a;

此时两个线程拿到的锁都是偏向锁。

5. 轻量级锁

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

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

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

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

代码证明&＃xff1a;

&＃64;Slf4j(topic &＃61; "s")
public class TestSync {static Object lock &＃61; new Object();public static void main(String[] args) throws InterruptedException {TimeUnit.SECONDS.sleep(4);Lock lock &＃61; new Lock();ClassLayout classLayout &＃61; ClassLayout.parseInstance(lock);log.debug(classLayout.toPrintable());new Thread(()->{synchronized (lock){log.debug("------------偏向锁 第一次------------");ClassLayout c &＃61; ClassLayout.parseInstance(lock);log.debug(c.toPrintable());}},"t1").start();TimeUnit.SECONDS.sleep(1);new Thread(()->{synchronized (lock){log.debug("------------轻量级锁------------");ClassLayout c &＃61; ClassLayout.parseInstance(lock);log.debug(c.toPrintable());try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}}log.debug("锁释放了之后");ClassLayout c &＃61; ClassLayout.parseInstance(lock);log.debug(c.toPrintable());},"t2").start();}
}


运行的结果如下&＃xff1a;

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

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

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

6. 重量级锁

也是发生在多个线程拿锁的时候&＃xff0c;

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

代码证明&＃xff1a;

&＃64;Slf4j(topic &＃61; "s")
public class TestSync {static Object lock &＃61; new Object();public static void main(String[] args) throws InterruptedException {TimeUnit.SECONDS.sleep(4);Lock lock &＃61; new Lock();ClassLayout classLayout &＃61; ClassLayout.parseInstance(lock);log.debug(classLayout.toPrintable());new Thread(()->{synchronized (lock){log.debug("------------偏向锁 第一次------------");ClassLayout c &＃61; ClassLayout.parseInstance(lock);log.debug(c.toPrintable());}},"t1").start();TimeUnit.SECONDS.sleep(1);new Thread(()->{synchronized (lock){log.debug("------------轻量级锁------------");ClassLayout c &＃61; 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 &＃61; ClassLayout.parseInstance(lock);log.debug(c2.toPrintable());}},"t3").start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}}},"t2").start();}
}


运行结果如下&＃xff1a;

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

7. synchronized锁升级总结

• JVM 4秒默认的偏向锁启动延迟
• 若不考虑偏向锁的启动延迟&＃xff0c;当仅有一个线程拿锁的时候&＃xff0c;锁对象的状态是偏向锁状态
• 当多个线程拿锁的时候&＃xff0c;若是交替拿锁不发生竞争或者发生竞争线程自旋的次数小于某阈值&＃xff0c;偏向锁升级成轻量级锁。
• 当自旋的次数超过某阈值&＃xff0c;轻量级锁升级成重量级锁