快速掌握并发编程---锁优化篇

关注“Java后端技术全栈”**

回复“000”获取大量电子书

无锁-->偏向锁-->轻量级锁-->重量级锁（真正意义上的加锁）

JDK1.6之前是基于重量级锁来实现的。

什么是重量级锁？

重量级锁就是如果存在线程竞争，会把线程挂起来，等其他线程释放锁后，再去唤醒挂起的线程。因为线程的挂起和唤醒需要从内核态到用户态的切换，这个切换需要操作系统的支持，性能消耗非常大。

尽然保证数据安全，也要保证性能，怎么优化？除了基于锁的粒度的控制以外，

其实没什么方法了，顶多就是无锁化了。

所以就引入了偏向锁和轻量级锁。

synchronized(lock){
 //同步代码块
}

常见业务场景，比如有两个线程T1和T2访问同步代码块：

只有T1去访问同步代码块（大部分属于这种）：引入偏向锁（CAS），T1的ThreadId、偏向锁标记，可以关闭的。
T1和T2交替访问：轻量级锁---自旋（死循环CAS，死循环一定次数）
多个线程同时访问：重量级锁--阻塞；

前面两种都是基于无锁来实现的。

能动手的咱们尽量别动口。

synchronized 锁的升级

在分析 markword 时，提到了偏向锁、轻量级锁、重量级锁。在分析这几种锁的区别时，我们先来思考一个问题使用锁能够实现数据的安全性，但是会带来性能的下降。不使用锁能够基于线程并行提升程序性能，但是却不能保证线程安全性。这两者之间似乎是没有办法达到既能满足性能也能满足安全性的要求。

hotspot 虚拟机的作者经过调查发现，大部分情况下，加锁的代码不仅仅不存在多线程竞争，而且总是由同一个线程多次获得。所以基于这样一个概率，是的 synchronized 在JDK1.6 之后做了一些优化，为了减少获得锁和释放锁带来的性能开销，引入了偏向锁、轻量级锁的概念。

因此大家会发现在 synchronized 中，锁存在四种状态分别是：无锁、偏向锁、轻量级锁、重量级锁；

锁的状态根据竞争激烈的程度从低到高不断升级。

偏向锁的基本原理

前面说过，大部分情况下，锁不仅仅不存在多线程竞争，而是总是由同一个线程多次获得，为了让线程获取锁的代价更低就引入了偏向锁的概念。

怎么理解偏向锁呢？

当一个线程访问加了同步锁的代码块时，会在对象头中存储当前线程的 ID，后续这个线程进入和退出这段加了同步锁的代码块时，不需要再次加锁和释放锁。而是直接比较对象头里面是否存储了指向当前线程的偏向锁。如果相等表示偏向锁是偏向于当前线程的，就不需要再尝试获得锁了。

偏向锁的获取和撤销逻辑

首先获取锁对象的 Markword，判断是否处于可偏向状态。（biased_lock=1、且 ThreadId 为空）
如果是可偏向状态，则通过 CAS 操作，把当前线程的 ID写入到 MarkWord
a) 如果 cas 成功，那么 markword 就会变成这样。表示已经获得了锁对象的偏向锁，接着执行同步代码块
b) 如果 cas 失败，说明有其他线程已经获得了偏向锁，这种情况说明当前锁存在竞争，需要撤销已获得偏向锁的线程，并且把它持有的锁升级为轻量级锁（这个操作需要等到全局安全点，也就是没有线程在执行字节码）才能执行
如果是已偏向状态，需要检查 markword 中存储的ThreadID 是否等于当前线程的 ThreadID
a) 如果相等，不需要再次获得锁，可直接执行同步代码块
b) 如果不相等，说明当前锁偏向于其他线程，需要撤销偏向锁并升级到轻量级锁

偏向锁的撤销

偏向锁的撤销并不是把对象恢复到无锁可偏向状态（因为偏向锁并不存在锁释放的概念），而是在获取偏向锁的过程中，发现 cas 失败也就是存在线程竞争时，直接把被偏向的锁对象升级到被加了轻量级锁的状态。

对原持有偏向锁的线程进行撤销时，原获得偏向锁的线程有两种情况：

原获得偏向锁的线程如果已经退出了临界区，也就是同步代码块执行完了，那么这个时候会把对象头设置成无锁状态并且争抢锁的线程可以基于 CAS 重新偏向当前线程。
如果原获得偏向锁的线程的同步代码块还没执行完，处于临界区之内，这个时候会把原获得偏向锁的线程升级为轻量级锁后继续执行同步代码块。

在我们的应用开发中，绝大部分情况下一定会存在 2 个以上的线程竞争，那么如果开启偏向锁，反而会提升获取锁的资源消耗。所以可以通过 jvm 参数UseBiasedLocking 来设置开启或关闭偏向锁。

轻量级锁的基本原理

轻量级锁的加锁和解锁逻辑

锁升级为轻量级锁之后，对象的 Markword 也会进行相应的的变化。升级为轻量级锁的过程：

线程在自己的栈桢中创建锁记录 LockRecord。
将锁对象的对象头中的MarkWord复制到线程的刚刚创建的锁记录中。
将锁记录中的 Owner 指针指向锁对象。
将锁对象的对象头的MarkWord替换为指向锁记录的指针。

自旋锁

轻量级锁在加锁过程中，用到了自旋锁所谓自旋，就是指当有另外一个线程来竞争锁时，这个线程会在原地循环等待，而不是把该线程给阻塞，直到那个获得锁的线程释放锁之后，这个线程就可以马上获得锁的。注意，锁在原地循环的时候，是会消耗 cpu 的，就相当于在执行一个啥也没有的 for 循环。
所以，轻量级锁适用于那些同步代码块执行的很快的场景，这样，线程原地等待很短的时间就能够获得锁了。

自旋锁的使用，其实也是有一定的概率背景，在大部分同步代码块执行的时间都是很短的。所以通过看似无异议的循环反而能提升锁的性能。
但是自旋必须要有一定的条件控制，否则如果一个线程执行同步代码块的时间很长，那么这个线程不断的循环反而会消耗 CPU 资源。

默认情况下自旋的次数是 10 次，可以通过 preBlockSpin 来修改。

在 JDK1.6 之后，引入了自适应自旋锁，自适应意味着自旋的次数不是固定不变的，而是根据前一次在同一个锁上自旋的时间以及锁的拥有者的状态来决定。
如果在同一个锁对象上，自旋等待刚刚成功获得过锁，并且持有锁的线程正在运行中，那么虚拟机就会认为这次自旋也是很有可能再次成功，进而它将允许自旋等待持续相对更长的时间。如果对于某个锁，自旋很少成功获得过，那在以后尝试获取这个锁时将可能省略掉自旋过程，直接阻塞线程，避免浪费处理器资源

轻量级锁的解锁

轻量级锁的锁释放逻辑其实就是获得锁的逆向逻辑，通过CAS 操作把线程栈帧中的 LockRecord 替换回到锁对象的MarkWord 中，如果成功表示没有竞争。如果失败，表示当前锁存在竞争，那么轻量级锁就会膨胀成为重量级锁。

重量级锁的基本原理

当轻量级锁膨胀到重量级锁之后，意味着线程只能被挂起阻塞来等待被唤醒了。

重量级锁的 monitor

在上一篇文章中有提到，加了同步代码块以后，在字节码中会看到一个monitorenter和 monitorexit。每一个 JAVA 对象都会与一个监视器 monitor 关联，我们可以把它理解成为一把锁，当一个线程想要执行一段被synchronized 修饰的同步方法或者代码块时，该线程得先获取到 synchronized 修饰的对象对应的 monitor。
monitorenter 表示去获得一个对象监视器。monitorexit 表示释放 monitor 监视器的所有权，使得其他被阻塞的线程可以尝试去获得这个监视器monitor 依赖操作系统的 MutexLock(互斥锁)来实现的, 线程被阻塞后便进入内核（Linux）调度状态，这个会导致系统在用户态与内核态之间来回切换，严重影响锁的性能。

任意线程对 Object（Object 由 synchronized 保护）的访问，首先要获得 Object 的监视器。如果获取失败，线程进入同步队列，线程状态变为 BLOCKED。当访问 Object 的前驱（获得了锁的线程）释放了锁，则该释放操作唤醒阻塞在同步队列中的线程，使其重新尝试对监视器的获取。

回顾线程的竞争机制

再来回顾一下线程的竞争机制对于锁升级这块的一些基本流程。方便大家更好的理解加入有这样一个同步代码块，存在 Thread#1、Thread#2 等多个线程

synchronized (lock) {
// do something
}

情况一：只有 Thread#1 会进入临界区；
情况二：Thread#1 和 Thread#2 交替进入临界区,竞争不激烈；
情况三：Thread#1/Thread#2/Thread3… 同时进入临界区，竞争激烈；

偏向锁

此时当 Thread#1 进入临界区时，JVM 会将 lockObject 的对象头 Mark Word 的锁标志位设为“01”，同时会用 CAS 操作把 Thread#1 的线程 ID 记录到 Mark Word 中，此时进入偏向模式。所谓“偏向”，指的是这个锁会偏向于 Thread#1，若接下来没有其他线程进入临界区，则 Thread#1 再出入临界区无需再执行任何同步操作。也就是说，若只有Thread#1 会进入临界区，实际上只有 Thread#1 初次进入临界区时需要执行 CAS 操作，以后再出入临界区都不会有同步操作带来的开销。

轻量级锁

偏向锁的场景太过于理想化，更多的时候是 Thread#2 也会尝试进入临界区，如果 Thread#2 也进入临界区但是Thread#1 还没有执行完同步代码块时，会暂停 Thread#1并且升级到轻量级锁。Thread#2 通过自旋再次尝试以轻量级锁的方式来获取锁。

没有自旋锁而是自旋方式的锁---轻量级锁。

重量级锁

如果 Thread#1 和 Thread#2 正常交替执行，那么轻量级锁基本能够满足锁的需求。但是如果 Thread#1 和 Thread#2同时进入临界区，那么轻量级锁就会膨胀为重量级锁，意味着 Thread#1 线程获得了重量级锁的情况下，Thread#2就会被阻塞。

白话版总结锁升级

就相当于上厕所（厕所里只能容纳一个人）：

张三来上厕所，敲门发现里面没有人（偏向锁），于是进直接进去关上门，开始拉。
李四来也来上厕所，敲门发现有人，过会再来敲门，发现还在，….不断敲门（轻量级锁），
张三实在是受不了李四的敲门，于是骂了一句哪个傻X呀，老子在拉屎呢，别敲了（重量级锁）。
这时候李四没办法了，只好继续等待张三拉完出来后，再进去拉屎。