当前位置：首页 > news >正文

JUC: synchronized与锁升级

news 2025/9/30 12:31:20

4.10.1 面试题

谈谈你对synchronized的理解
synchronized的锁升级机制是什么？
偏向锁和轻量锁有什么区别？

高并发时，同步调用应该去考量锁的性能损耗。能用无锁的数据结构，就不要用锁。能用锁块，就不要锁整个方法体；能用对象锁，就不要用类锁。

说明：尽可能使加锁的代码块工作量尽可能小，避免在锁代码块中调用RPC方法。

锁的升级过程
- 无锁 >> 偏向锁 >> 轻量级锁 >> 重量级锁
- 无锁 >> 独占锁 >> 读写锁 >> 邮戳锁

4.10.2 synchronized锁原理

java的线程是映射到操作系统原生线程之上的，如果要阻塞或唤醒一个线程就需要操作系统介入，需要在户态与核心态之间切换，这种切换会消耗大量的系统资源，因为用户态与内核态都有各自专用的内存空间，专用的寄存器等，用户态切换至内核态需要传递给许多变量、参数给内核，内核也需要保护好用户态在切换时的一些寄存器值、变量等，以便内核态调用结束后切换回用户态继续工作。

在Java早期版本中，synchronized属于重量级锁，效率低下，因为监视器锁(monitor)是依赖于底层的操作系统的Mutex Lock(系统互斥量)来实现的，挂起线程和恢复线程都需要转入内核态去完成，阻塞或唤醒一个ava线程需要操作系统切换CPU状态来完成，这种状态切换需要耗费处理器时间，如果同步代码块中内容过于简单，这种切换的时间可能比用户代码执行的时间还长”，时间成本相对较高，这也是为什么早期的svnchronized效率低的原因

Java6之后，为了减少获得锁和释放锁所带来的性能消耗，引入了轻量级锁和偏向锁

Montor可以理解为一种同步工具，也可理解为一种同步机制，常常被描述为一个Java对象。Java对象是天生的Monitor，每一个Java对象都有成为
Monitor的潜质，因为在Java的设计中，每一个java对象自打娘胎里出来就带了一把看不见的锁，它叫做内部锁或者Monitor锁。

Monitor的本质是依赖于底层操作系统的MutexLock实现，操作系统实现线程之间的切换需要从用户态到内核态的转换，成本非常高。

JVM中的同步就是基于进入和退出管程(Monitor)对象实现的。每个对象实例都会有一个 Monitor，Monitor 可以和对象一起创建、销毁。

Monitor是由ObjectMonitor实现，而ObjectMonitor是由C++的ObjectMonitor.hpp文件实现，如下所示:

//结构体如下
ObjectMonitor::ObjectMonitor() {  _header       = NULL;  _count       = 0;   // 该线程获取锁的次数_waiters      = 0,  _recursions   = 0;       //线程的重入次数_object       = NULL;  _owner        = NULL;    //标识拥有该monitor的线程_WaitSet      = NULL;    //等待线程组成的双向循环链表，_WaitSet是第一个节点_WaitSetLock  = 0 ;  _Responsible  = NULL ;  _succ         = NULL ;  _cxq          = NULL ;    //多线程竞争锁进入时的单向链表FreeNext      = NULL ;  _EntryList    = NULL ;    //_owner从该双向循环链表中唤醒线程结点，_EntryList是第一个节点_SpinFreq     = 0 ;  _SpinClock    = 0 ;  OwnerIsThread = 0 ;  
}

Monitor是在ivm底层实现的，底层代码是c++。本质是依赖于底层操作系统的MtexLocK实现，操作系统实现线程之问的切换需要从用户态到内核态的转换，状态转换需要耗费很多的处理器时间成本非常高。所以synchronized是Java语言中的一个重量级操作。

Monitor与Java对象以及线程是如何关联的？

如果一个java对象被某个线程锁住，则该java对象的Mark Word字段中LockWord(重量级锁) 指向monitor的起始地址
Monitor的Owner字段会存放拥有相关关联对象锁的线程ID。

Mutex Lock 的切换需要从用户态转换到核心态中，因此状态转换需要耗费很多的处理器时间。

4.10.3 synchronized锁种类及升级步骤

（1）多线程访问情况

只有一个线程访问
有两个线程交替访问
有多个线程来访问

synchronized 用到锁是存在Java对象头的MarkWord中，锁升级功能主要依赖MarkWord中锁标志位和释放偏向锁标志位

偏向锁：MarkWord存储的是偏向的线程ID
轻量锁：MarkWord存储的是指向线程栈中Lock Record的指针
重量锁：MarkWord存储的是指向堆中的Monitor对象的指针

（2）升级流程

（3）无锁 001

初始状态：如果一个对象被实例化之后，如果还没有被任何线程竞争锁，那么它就为无锁状态（001）

（4）偏向锁 101

偏向锁：单线程竞争

当线程A第一次竞争到锁时，通过操作修改Mark Word中的偏向线程ID、偏向模式。如果不存在其他线程竞争，那么持有偏向锁的线程将永远不需要进行同步。

主要作用：

当一段同步代码块一直被同一个线程多次访问，由于只有一个线程那么该线程在后续访问时，便会自动获取锁。避免用户态到内核态的频繁切换。

多线程的情况下，锁不仅不存在多线程竞争，还存在锁由同一个线程多次获得的情况

偏向锁就是在这种情况下出现的，它的出现是为了解决只有在一个线程执行同步时提高性能。

备注:
偏向锁会偏向于第一个访问锁的线程，如果在接下来的运行过程中，该锁没有被其他的线程访问，则持有偏向锁的线程将永远不需要触发同步。也即偏向锁在资源没有竞争情况下消除了同步语句，懒的连CAS操作都不做了，直接提高程序性能

在实际应用运行过程中发现，“锁总是同一个线程持有，很少发生竞争”，也就是说锁总是被第一个占用他的线程拥有，这个线程就是锁的偏向线程。

那么只需要在锁第一次被拥有的时候，记录下偏向线程ID。这样偏向线程就一直持有着锁(后续这个线程进入和退出这段加了同步锁的代码块时，不需要再次加锁和释放锁。而是直接会去检査锁的MarkWord里面是不是放的自己的线程ID)。

如果相等，表示偏向锁是偏向于当前线程的，就不需要再尝试获得锁了，直到竞争发生才释放锁。以后每次同步，检查锁的偏向线程D与当前线程ID是否一致，如果一致直接进入同步。无需每次加锁解锁都去CAS更新对象头。如果自始至终使用锁的线程只有一个，很明显偏向锁几乎没有额外开销，性能极高。
如果不等，表示发生了竞争，锁已经不是总是偏向于同一个线程了，这个时候会尝试使用CAS来替换MarkWord里面的线程ID为新线程的ID，
- 竞争成功，表示之前的线程不存在了， MarkWord里面的线程ID为新线程的ID，锁不会升级，仍然为偏向锁
- 竞争失败，这时候可能需要升级变为轻量级锁，才能保证线程间公平竞争锁。
注意，偏向锁只有遇到其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁，线程是不会主动释放偏向锁的。

技术实现:

一个synchronized方法被一个线程抢到了锁时，那这个方法所在的对象就会在其所在的Mark Word中将偏向锁修改状态位，同时还会有占用前54位来存储线程指针作为标识。若该线程再次访问同一个synchronized方法时，该线程只需去对象头的Mark Word 中判断是否有偏向锁指向本线程的ID，无需再进入ObjectMonitor 去竞争对象了。

举例：

假如有一个线程执行到synchronized代码块的时候，JVM使用CAS操作把线程指针ID记录到Mark Word当中，并修改偏向标示，标示当前线程就获得该锁。锁对象变成偏向锁(通过CAS修改对象头里的锁标志位)，字面意思是偏向于第一个获得它的线程的锁。执行完同步代码块后，线程并不会主动释放偏向锁。

这时线程获得了锁，可以执行同步代码块。当该线程第二次到达同步代码块时会判断此时持有锁的线程是否还是自己(持有锁的线程ID也在对象头里)，JVM通过对象的MarkWord判断，当前线程ID还在，说明还持有着这个对象的锁，就可以继续进入临界区工作。由于之前没有释放锁，这里也就不需要重新加锁。如果自始有终使用锁的线程只有一个，很明显偏向锁几乎没有额外开销，性能极高。

结论: JVM不用和操作系统协商设置Mutex(争取内核)，它只需要记录下线程ID, 就标示自己获得了当前锁，不用操作系统接入。

上述就是偏向锁; 在没有其他线程竞争的时候，一直偏向当前线程，当前线程可以一直执行。

默认偏向锁延时为4秒: JVM启动延迟：为了优化启动性能，JVM在启动后的头几秒（默认4秒）内是禁止偏向锁的。在此期间创建的对象，其Mark Word直接是无锁状态（001），任何锁竞争都会直接触发轻量级锁的升级路径

如果确定锁通常处于竞争状态，则可以通过JVM参数-XX:-UseBiasedLocking关闭偏向锁，那么默认会进入轻量级锁。

偏向锁的撤销：

当有另外的线程逐步来竞争锁的时候，就不能再使用偏向锁了，要升级为轻量级锁。

竞争线程尝试CAS更新对象头失败，会等待到全局安全点(此时不会执行任何代码) 撤销偏向锁.

偏向锁使用一种等到竞争出现才释放锁的机制，只有当其他线程竞争锁时，持有偏向锁的原来线程才会被撤销。撤销需要等待全局安全点(该时间点上没有字节码正在执行)，同时检査持有偏向锁的线程是否还在执行:

第一个线程正在执行synchronized方法(处于同步块)，它还没有执行完，其它线程来抢夺，该偏向锁会被取消掉并出现锁升级。
此时轻量级锁由原持有偏向锁的线程持有，继续执行其同步代码，而正在竞争的线程会进入自旋等待获得该轻量级锁。
第一个线程执行完成synchronized方法(退出同步块)，则将对象头设置成无锁状态并撤销偏向锁，重新偏向。

java15之后逐步废弃偏向锁

JDK 版本	偏向锁状态	关键变化
JDK 15	默认禁用	通过 JEP 374，将偏向锁的启用参数 (`-XX:+UseBiasedLocking`) 设置为默认 `false`，标志着官方开始弃用此功能。
JDK 17	完全移除	偏向锁相关的代码被从 HotSpot 虚拟机中彻底移除，相应的 JVM 参数也不再有效

为什么移除偏向锁？

维护成本高昂：偏向锁的实现逻辑非常复杂，涉及到锁的撤销、批量重偏向、批量撤销等精细操作，给 JVM 的开发和维护带来了巨大负担
收益有限：在现代多核和高并发应用成为主流的背景下，能够真正从“只有一个线程访问”这种理想场景中获益的情况越来越少。大多数情况下，锁都存在一定程度的竞争，这使得偏向锁带来的性能提升变得不显著
撤销开销：当出现第二个线程尝试获取锁时，就需要撤销偏向锁。这个撤销过程需要进入全局安全点，暂停所有用户线程，其开销有时甚至超过了偏向锁本身带来的收益

移除偏向锁后，synchronized的锁升级路径变得更加简洁和高效： 无锁 >> 轻量级锁 >> 重量级锁

（5）轻量级锁 `0`00

轻量级锁：多线程竞争，但是任意时刻最多只有一个线程竞争，即不存在锁竞争太过激烈的情况，也就没有了线程阻塞

主要作用：

有线程来参与锁的竞争，但是获取锁的冲突时间极短
本质就是自旋锁CAS

轻量级锁是为了在线程近乎交替执行同步块时提高性能。

主要目的: 在没有多线程竞争的前提下，通过CAS减少重量级锁使用操作系统互斥量产生的性能消耗，说白了先自旋，不行才升级阻塞。升级时机:当关闭偏向锁功能或多线程竞争偏向锁会导致偏向锁升级为轻量级锁

假如线程A已经拿到锁，这时线程B又来抢该对象的锁，由于该对象的锁已经被线程A拿到，当前该锁已是偏向锁了。而线程B在争抢时发现对象头Mark Word中的线程ID不是线程B自己的线程ID(而是线程A)，那线程B就会进行CAS操作希望能获得锁。此时线程B操作中有两种情况:

如果锁获取成功，直接替换Mark Word中的线程ID为B自己的ID(A →B)，重新偏向于其他线程(即将偏向锁交给其他线程，相当于当前线程"被"释放了锁)，该锁会保持偏向锁状态，A线程Over，B线程上位:
如果锁获取失败，则偏向锁开级为轻量级锁(设置偏向锁标识为0并设置锁标志位为00)，此时轻量级锁由原拥有偏向锁的线程持有，继续执行其同出
代码，而正在竞争的线程B会进入自旋等待获得该轻量级锁。

轻量级锁的加锁：

线程栈帧中： JVM会为每个线程在当前线程的方法栈帧中创建用于存储锁记录的空间，官方成为Displaced Mark Word。

若一个线程获得锁时发现是轻量级锁，会把锁的Markword复制到自己的方法栈帧的Disolaced Mark word果面，然后线程尝试: CAS将锁的MarkWord替换为指向当前线程锁记录的指针。

如果成功，当前线程获得锁
如果失败，表示Mark Word已经被替换成了其他线程的锁记录，说明在与其它线程竞争锁，当前线程就尝试使用自旋来获取锁。

自旋CAS: 不断尝试去获取锁，能不升级就不往上捅，尽量不要阻塞

轻量级锁的释放：

在释放锁时，当前线程会使用CAS操作将Displaced Mark Word的内容复制回锁的Mark Word里面。如果没有发生竞争，那么这个复制的操作会成功。如果有其他线程因为自旋多次导致轻量级锁升级成了重量级锁，那么CAS操作会失败，此时会释放锁并唤醒被阻塞

自旋达到一定程度后：

Java6之前: 默认启用，默认情况下自旋的次数是10次； -XX:PreBlockSpin=10
Java6之后：自适应自旋锁
- 如果自旋成功，下次自旋最大次数会增加
- 如果自旋失败，下次自旋最大次数会减少

偏向锁和轻量级锁区别：

争夺轻量级锁失败，会尝试自旋抢占锁
轻量级锁每次退出同步块都需要释放锁，而偏向锁是竞争发生时才释放锁。

（6）重量级锁`0`10

Java中synchronized的重量级锁，是基于进入和退出Monitor对象实现的。在编译时会将同步块的开始位置插入monitor enter指令，在结束位置插入monitor exit指令。

当线程执行到monitor enter指令时，会尝试获取对象所对应的Monitor所有权，如果获取到了，即获取到了锁，会在Monitor的owner中存放当前线程的id，这样它将处于锁定状态，其他线程获取不到锁会处于被阻塞的状态（BLOCKED）。除非退出同步块，否则其他线程无法获取到这个Monitor。

（7）总结

锁升级后，hashcode去哪了？
- 锁升级为轻量级或重量级锁后，Mark Word中保存的分别是线程栈帧里的锁记录指针和重量级锁指针，已经没有位置再保存哈希码，
  GC年龄了，那么这些信息被移动到哪里去了呢?
  - 如果处于无锁状态，又计算了hashcode，加锁时，则直接升级为轻量级锁
  - 如果处于偏向锁状态，计算hashcode时，会先升级为重量级锁
  - 升级为轻量级锁时，JVM会在当前线程的栈帧中创建一个锁记录(Lock Record)空间，用于存储锁对象的Mark Word拷贝，该拷贝中可以包含identity hash code，所以轻量级锁可以和identity hash code共存，哈希码和GC年龄自然保存在此，释放锁后会将这些信息写回到对象头。
  - 重量级锁，mark word存储monitor指针，monitor有字段记录非加锁状态时的Mark Word，释放锁之后写回到对象头中
各种锁的优缺点
- 偏向锁：适用于只有一个线程访问同步代码块
- 轻量级锁：竞争的线程不会阻塞，提高了响应速度。长时间消耗的cpu资源较多。追求响应时间，同步块执行速度非常快的代码。
- 重量级锁：线程阻塞，响应时间慢。追求吞吐量，同步块执行时间长的代码。
synchronized锁升级和实现原理
- 先自旋，再升级阻塞

4.10.4 JIT编译器对锁的优化

JIT: Just In Compiler: 即时编译器

（1）锁消除

public void m1(){Object o = new Object();synchronized (o){ // JIT会优化，相当于不存在System.out.println(ClassLayout.parseInstance(o).toPrintable());}
}

（2）锁粗化

public void m1(){Object o = new Object();synchronized (o){ // JIT会优化四个锁为一个锁System.out.println("1");}synchronized (o){ // JIT会优化四个锁为一个锁System.out.println("2");}synchronized (o){ // JIT会优化四个锁为一个锁System.out.println("3");}synchronized (o){ // JIT会优化四个锁为一个锁System.out.println("4");}
}// 以上等同于
public void m1(){Object o = new Object();synchronized (o){ // JIT会优化四个锁为一个锁System.out.println("1");System.out.println("2");System.out.println("3");System.out.println("4");}
}