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中记录的信息没变 此时锁还是偏向锁。
5. 轻量级锁
当有多个线程去获得锁的时候，分两种情况
第一种是多个线程先后交替的去获得锁，此时不存在同时抢锁，对象锁会从偏向锁转变成轻量级锁。
当一个线程尝试的去获得对象锁，会将当前对象锁的mark word复制到线程栈中的锁记录当中。然后使用cas 去修改对象锁的中的mark word的内容，设置一个指针指向线程栈中的锁记录，如果cas成功则获得到这个锁。
一个线程释放锁的时候，使用cas将锁记录当中的mark word 替换回对象头当中。
第二种情况是多个线程存在同时抢锁，假设现在有2个线程，第一个线程得到了锁，第二个线程必定是拿不到锁的，需要等到第一个线程释放掉锁。此时第二个线程并不会阻塞，而是采用自旋的方式继续使用cas来尝试的获得锁。若在自旋的次数还没达到某个阈值之前，第二个线程获得了锁，那么此时的对象锁还是轻量级的锁。
代码证明：
@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秒默认的偏向锁启动延迟
- 若不考虑偏向锁的启动延迟，当仅有一个线程拿锁的时候，锁对象的状态是偏向锁状态
- 当多个线程拿锁的时候，若是交替拿锁不发生竞争或者发生竞争线程自旋的次数小于某阈值，偏向锁升级成轻量级锁。
- 当自旋的次数超过某阈值，轻量级锁升级成重量级锁