Java并发编程：Synchronized底层优化（偏向锁、轻量级锁）

淡淡的烟草味﹌ 2022-06-10 04:14 264阅读 0赞

一、重量级锁

上篇文章中向大家介绍了Synchronized的用法及其实现的原理。现在我们应该知道，Synchronized是通过对象内部的一个叫做监视器锁（monitor）来实现的。但是监视器锁本质又是依赖于底层的操作系统的Mutex Lock来实现的。而操作系统实现线程之间的切换这就需要从用户态转换到核心态，这个成本非常高，状态之间的转换需要相对比较长的时间，这就是为什么Synchronized效率低的原因。因此，这种依赖于操作系统Mutex Lock所实现的锁我们称之为“重量级锁”。JDK中对Synchronized做的种种优化，其核心都是为了减少这种重量级锁的使用。JDK1.6以后，为了减少获得锁和释放锁所带来的性能消耗，提高性能，引入了“轻量级锁”和“偏向锁”。

二、轻量级锁

锁的状态总共有四种：无锁状态、偏向锁、轻量级锁和重量级锁。随着锁的竞争，锁可以从偏向锁升级到轻量级锁，再升级的重量级锁（但是锁的升级是单向的，也就是说只能从低到高升级，不会出现锁的降级）。JDK 1.6中默认是开启偏向锁和轻量级锁的，我们也可以通过-XX:-UseBiasedLocking来禁用偏向锁。锁的状态保存在对象的头文件中，以32位的JDK为例：

<table style="margin:0px; padding:0px; border-collapse:collapse; border-spacing:0px; max-width:850px; border:1px solid silver; word-break:break-word; width:800px"> 
 <tbody style="margin:0px; padding:0px"> 
 <tr style="margin:0px; padding:0px"> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 锁状态 </td> 
 <td colspan="3" style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 25 bit </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 4bit </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 1bit </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 2bit </td> 
 </tr> 
 <tr style="margin:0px; padding:0px"> 
 <td colspan="2" style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 23bit </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 2bit </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 是否是偏向锁 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 锁标志位 </td> 
 </tr> 
 <tr style="margin:0px; padding:0px"> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 轻量级锁 </td> 
 <td colspan="5" style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 指向栈中锁记录的指针 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 00 </td> 
 </tr> 
 <tr style="margin:0px; padding:0px"> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 重量级锁 </td> 
 <td colspan="5" style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 指向互斥量（重量级锁）的指针 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 10 </td> 
 </tr> 
 <tr style="margin:0px; padding:0px"> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> GC标记 </td> 
 <td colspan="5" style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 空 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 11 </td> 
 </tr> 
 <tr style="margin:0px; padding:0px"> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 偏向锁 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 线程ID </td> 
 <td colspan="2" style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> Epoch </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 对象分代年龄 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 1 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 01 </td> 
 </tr> 
 <tr style="margin:0px; padding:0px"> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 无锁 </td> 
 <td colspan="3" style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 对象的hashCode </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 对象分代年龄 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 0 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 01 </td> 
 </tr> 
 </tbody> 
</table>

“轻量级”是相对于使用操作系统互斥量来实现的传统锁而言的。但是，首先需要强调一点的是，轻量级锁并不是用来代替重量级锁的，它的本意是在没有多线程竞争的前提下，减少传统的重量级锁使用产生的性能消耗。在解释轻量级锁的执行过程之前，先明白一点，轻量级锁所适应的场景是线程交替执行同步块的情况，如果存在同一时间访问同一锁的情况，就会导致轻量级锁膨胀为重量级锁。

1、轻量级锁的加锁过程

（1）在代码进入同步块的时候，如果同步对象锁状态为无锁状态（锁标志位为“01”状态，是否为偏向锁为“0”），虚拟机首先将在当前线程的栈帧中建立一个名为锁记录（Lock Record）的空间，用于存储锁对象目前的Mark Word的拷贝，官方称之为 Displaced Mark Word。这时候线程堆栈与对象头的状态如图2.1所示。

（2）拷贝对象头中的Mark Word复制到锁记录中。

（3）拷贝成功后，虚拟机将使用CAS操作尝试将对象的Mark Word更新为指向Lock Record的指针，并将Lock record里的owner指针指向object mark word。如果更新成功，则执行步骤（3），否则执行步骤（4）。

（4）如果这个更新动作成功了，那么这个线程就拥有了该对象的锁，并且对象Mark Word的锁标志位设置为“00”，即表示此对象处于轻量级锁定状态，这时候线程堆栈与对象头的状态如图2.2所示。

（5）如果这个更新操作失败了，虚拟机首先会检查对象的Mark Word是否指向当前线程的栈帧，如果是就说明当前线程已经拥有了这个对象的锁，那就可以直接进入同步块继续执行。否则说明多个线程竞争锁，轻量级锁就要膨胀为重量级锁，锁标志的状态值变为“10”，Mark Word中存储的就是指向重量级锁（互斥量）的指针，后面等待锁的线程也要进入阻塞状态。 而当前线程便尝试使用自旋来获取锁，自旋就是为了不让线程阻塞，而采用循环去获取锁的过程。

![820406-20160424105442866-2111954866.png][]

图2.1 轻量级锁CAS操作之前堆栈与对象的状态

![820406-20160424105540163-1019388398.png][]

图2.2 轻量级锁CAS操作之后堆栈与对象的状态

2、轻量级锁的解锁过程：

（1）通过CAS操作尝试把线程中复制的Displaced Mark Word对象替换当前的Mark Word。

（2）如果替换成功，整个同步过程就完成了。

（3）如果替换失败，说明有其他线程尝试过获取该锁（此时锁已膨胀），那就要在释放锁的同时，唤醒被挂起的线程。

三、偏向锁

引入偏向锁是为了在无多线程竞争的情况下尽量减少不必要的轻量级锁执行路径，因为轻量级锁的获取及释放依赖多次CAS原子指令，而偏向锁只需要在置换ThreadID的时候依赖一次CAS原子指令（由于一旦出现多线程竞争的情况就必须撤销偏向锁，所以偏向锁的撤销操作的性能损耗必须小于节省下来的CAS原子指令的性能消耗）。上面说过，轻量级锁是为了在线程交替执行同步块时提高性能，而偏向锁则是在只有一个线程执行同步块时进一步提高性能。

1、偏向锁获取过程：

（1）访问Mark Word中偏向锁的标识是否设置成1，锁标志位是否为01——确认为可偏向状态。

（2）如果为可偏向状态，则测试线程ID是否指向当前线程，如果是，进入步骤（5），否则进入步骤（3）。

（3）如果线程ID并未指向当前线程，则通过CAS操作竞争锁。如果竞争成功，则将Mark Word中线程ID设置为当前线程ID，然后执行（5）；如果竞争失败，执行（4）。

（4）如果CAS获取偏向锁失败，则表示有竞争。当到达全局安全点（safepoint）时获得偏向锁的线程被挂起，偏向锁升级为轻量级锁，然后被阻塞在安全点的线程继续往下执行同步代码。

（5）执行同步代码。

2、偏向锁的释放：

偏向锁的撤销在上述第四步骤中有提到。偏向锁只有遇到其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁，线程不会主动去释放偏向锁。偏向锁的撤销，需要等待全局安全点（在这个时间点上没有字节码正在执行），它会首先暂停拥有偏向锁的线程，判断锁对象是否处于被锁定状态，撤销偏向锁后恢复到未锁定（标志位为“01”）或轻量级锁（标志位为“00”）的状态。

3、重量级锁、轻量级锁和偏向锁之间转换

![820406-20160424163618101-624122079.png][]

图 2.3三者的转换图

该图主要是对上述内容的总结，如果对上述内容有较好的了解的话，该图应该很容易看懂。

四、其他优化

1、适应性自旋（Adaptive Spinning）：从轻量级锁获取的流程中我们知道，当线程在获取轻量级锁的过程中执行CAS操作失败时，是要通过自旋来获取重量级锁的。问题在于，自旋是需要消耗CPU的，如果一直获取不到锁的话，那该线程就一直处在自旋状态，白白浪费CPU资源。解决这个问题最简单的办法就是指定自旋的次数，例如让其循环10次，如果还没获取到锁就进入阻塞状态。但是JDK采用了更聪明的方式——适应性自旋，简单来说就是线程如果自旋成功了，则下次自旋的次数会更多，如果自旋失败了，则自旋的次数就会减少。

2、锁粗化（Lock Coarsening）：锁粗化的概念应该比较好理解，就是将多次连接在一起的加锁、解锁操作合并为一次，将多个连续的锁扩展成一个范围更大的锁。举个例子：

![复制代码][copycode.gif]

1 package com.paddx.test.string;
     2 
     3 public class StringBufferTest {
     4     StringBuffer stringBuffer = new StringBuffer();
     5 
     6     public void append(){
     7         stringBuffer.append("a");
     8         stringBuffer.append("b");
     9         stringBuffer.append("c");
    10     }
    11 }

![复制代码][copycode.gif]

这里每次调用stringBuffer.append方法都需要加锁和解锁，如果虚拟机检测到有一系列连串的对同一个对象加锁和解锁操作，就会将其合并成一次范围更大的加锁和解锁操作，即在第一次append方法时进行加锁，最后一次append方法结束后进行解锁。

3、锁消除（Lock Elimination）：锁消除即删除不必要的加锁操作。根据代码逃逸技术，如果判断到一段代码中，堆上的数据不会逃逸出当前线程，那么可以认为这段代码是线程安全的，不必要加锁。看下面这段程序：

![复制代码][copycode.gif]

1 package com.paddx.test.concurrent;
 2 
 3 public class SynchronizedTest02 {
 4 
 5 public static void main(String[] args) {
 6 SynchronizedTest02 test02 = new SynchronizedTest02();
 7 //启动预热
 8 for (int i = 0; i < 10000; i++) {
 9 i++;
 10 }
 11 long start = System.currentTimeMillis();
 12 for (int i = 0; i < 100000000; i++) {
 13 test02.append("abc", "def");
 14 }
 15 System.out.println("Time=" + (System.currentTimeMillis() - start));
 16 }
 17 
 18 public void append(String str1, String str2) {
 19 StringBuffer sb = new StringBuffer();
 20 sb.append(str1).append(str2);
 21 }
 22 }

![复制代码][copycode.gif]

虽然StringBuffer的append是一个同步方法，但是这段程序中的StringBuffer属于一个局部变量，并且不会从该方法中逃逸出去，所以其实这过程是线程安全的，可以将锁消除。下面是我本地执行的结果：

![820406-20160424211554570-376308694.png][]

为了尽量减少其他因素的影响，这里禁用了偏向锁（-XX:-UseBiasedLocking）。通过上面程序，可以看出消除锁以后性能还是有比较大提升的。

注：可能JDK各个版本之间执行的结果不尽相同，我这里采用的JDK版本为1.6。

五、总结

本文重点介绍了JDk中采用轻量级锁和偏向锁等对Synchronized的优化，但是这两种锁也不是完全没缺点的，比如竞争比较激烈的时候，不但无法提升效率，反而会降低效率，因为多了一个锁升级的过程，这个时候就需要通过-XX:-UseBiasedLocking来禁用偏向锁。下面是这几种锁的对比：

<table style="margin:0px; padding:0px; border-collapse:collapse; border-spacing:0px; max-width:850px; border:1px solid silver; word-break:break-word; color:rgb(51,51,51); font-family:Verdana,Arial,Helvetica,sans-serif; font-size:14px"> 
 <tbody style="margin:0px; padding:0px"> 
 <tr style="margin:0px; padding:0px"> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 锁 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 优点 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 缺点 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 适用场景 </td> 
 </tr> 
 <tr style="margin:0px; padding:0px"> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 偏向锁 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 加锁和解锁不需要额外的消耗，和执行非同步方法比仅存在纳秒级的差距。 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 如果线程间存在锁竞争，会带来额外的锁撤销的消耗。 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 适用于只有一个线程访问同步块场景。 </td> 
 </tr> 
 <tr style="margin:0px; padding:0px"> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 轻量级锁 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 竞争的线程不会阻塞，提高了程序的响应速度。 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 如果始终得不到锁竞争的线程使用自旋会消耗CPU。 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 追求响应时间。 同步块执行速度非常快。 </td> 
 </tr> 
 <tr style="margin:0px; padding:0px"> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 重量级锁 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 线程竞争不使用自旋，不会消耗CPU。 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 线程阻塞，响应时间缓慢。 </td> 
 <td style="margin:0px; padding:3px; border:1px solid silver; border-collapse:collapse"> 追求吞吐量。 同步块执行速度较长。 </td> 
 </tr> 
 </tbody> 
</table>

原文地址：http://www.cnblogs.com/paddix/p/5405678.html

jdk1.5之后各个版本都针对并发锁这块做了优化，之前说synchornized的性能不如concurrent包中的Lock，jdk的高版本中可不能这么说，jdk5之后 synchornized的性能和Lock的性能其实差别不大，貌似jdk8中ConcurrentHashMap中已经取消了Segement（继承了ReetrantLock）而用了synchronized进行加锁，一切都因[Oracle][]公司对synchronize的性能做了一下方面的优化：（有时间再写）

纯属个人理解，

1 .自旋和适应性自旋

自旋锁：实际上是线程在获取锁的时候，在jvm的锁层面做了优化，每次在获取锁的时候，如果锁已经被持有，则不会立即挂起线程，应为挂起线程开销很大，线程会从核心态转化成用户态，涉及到线程调度。jvm的设计人员为了尽量少的避免线程调度，造成的系统系统开销，则会通过让程序线程处于核心态并且等一会儿，看看会不会得到锁，也就是让线程自旋处于忙等的状态，这个是可以通过jvm启动参数配置的，如果自旋完成还没拿到，才会从核心态转为用户态。

自适应自旋：是对自旋的更[智能][Link 1]的优化，会根据近期在这个锁上的线程自旋等待周期，算出一个合理的值，让当前线程根据这个值去自旋等待

自旋锁和自适应自旋其实是为了减少线程状态切换系统开销，适当的情况下可能会很有用，如果使用的不是很恰当很可能造成多余的线程忙等。

2.轻量级锁

轻量级锁：实际上它是在没有锁竞争的条件下，避免了重量级互斥锁，这样就提高了在系统的执行效率

3.偏向锁

偏向锁：偏向锁是对轻量级锁的进一步优化，减少了单线程情况下没有必要的自选等待。

锁的类型：偏向锁，轻量级锁，重量级锁

[820406-20160424105442866-2111954866.png]: /images/20220610/3766d9ad4077475aa7c5dfe4f97aa284.png
[820406-20160424105540163-1019388398.png]: /images/20220610/a8f53495c6534b05808eaa41317b32f2.png
[820406-20160424163618101-624122079.png]: /images/20220610/5d7f10b6be3b42298cf9f3bc08fb4624.png
[copycode.gif]: /images/20220610/daea06a0bfa14d84897fd7132ac7d132.png
[820406-20160424211554570-376308694.png]: /images/20220610/014debbcd8c44581b0c31d5674dc7dd0.png
[Oracle]: http://lib.csdn.net/base/oracle
[Link 1]: http://lib.csdn.net/base/aiplanning