一、synchronized简介
1.1 synchronized 的使用
synchronized关键字最主要有以下3种应用方式:
- 修饰实例方法,作用于当前实例加锁,进入同步代码前要获得当前实例的锁 ;
- 修饰静态方法,作用于当前类对象加锁,进入同步代码前要获得当前类对象的锁 ;
- 修饰代码块,指定加锁对象,对给定对象加锁,进入同步代码库前要获得给定对象的锁。

1.2 synchronized 在jdk1.6中的 4 个优化
早期JDK对synchronized的实现是重量级的,其底层是由操作系统的 mutex lock 提供的,每一次的获取锁都需要进行用户态和内核态的切换,这是非常消耗系统资源和性能的。
在JDK1.6中对锁进行了优化,核心优化方案如下:
1.2.1 锁膨胀/锁升级
锁膨胀是指 synchronized 从 无锁——>偏向锁——>轻量级锁——>重量级锁 的过程,它叫做锁膨胀也叫做锁升级。
JDK 1.6 之前,synchronized 是重量级锁,也就是说 synchronized 在释放和获取锁时都会从用户态转换成内核态,而转换的效率是比较低的。但有了锁膨胀机制之后,synchronized 的状态就多了无锁、偏向锁以及轻量级锁了,这时候在进行并发操作时,大部分的场景都不需要用户态到内核态的转换了,这样就大幅的提升了 synchronized 的性能。
1.2.2 锁消除
锁消除指的是在某些情况下,JVM 虚拟机如果检测不到某段代码被共享和竞争的可能性,就会将这段代码所属的同步锁消除掉,从而到底提高程序性能的目的。
锁消除的依据是逃逸分析的数据支持,如 StringBuffer#append() 方法,或 Vector#add() 方法,在很多情况下是可以进行锁消除的,比如以下这段代码:
public String method() {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < 10; i++) {
sb.append("i:" + i);
}
return sb.toString();
}
编译后的字节码如下:

从上述结果可以看出,之前我们写的线程安全的加锁的 StringBuffer 对象,在生成字节码之后就被替换成了不加锁不安全的 StringBuilder 对象了,原因是 StringBuffer 的变量属于一个局部变量,并且不会从该方法中逃逸出去,所以此时我们就可以使用锁消除(不加锁)来加速程序的运行。
1.2.3 锁粗化
锁粗化是指,将多个连续的加锁、解锁操作连接在一起,扩展成一个范围更大的锁。
我只听说锁“细化”可以提高程序的执行效率,也就是将锁的范围尽可能缩小,这样在锁竞争时,等待获取锁的线程才能更早的获取锁,从而提高程序的运行效率,但锁粗化是如何提高性能的呢?
没错,锁细化的观点在大多数情况下都是成立了,但是一系列连续加锁和解锁的操作,也会导致不必要的性能开销,从而影响程序的执行效率,比如这段代码:
public String method() {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10; i++) {
// 伪代码:加锁操作
sb.append("i:" + i);
// 伪代码:解锁操作
}
return sb.toString();
}
这里我们不考虑编译器优化的情况,如果在 for 循环中定义锁,那么锁的范围很小,但每次 for 循环都需要进行加锁和释放锁的操作,性能是很低的;但如果我们直接在 for 循环的外层加一把锁,那么对于同一个对象操作这段代码的性能就会提高很多,如下伪代码所示:
public String method() {
StringBuilder sb = new StringBuilder();
// 伪代码:加锁操作
for (int i = 0; i < 10; i++) {
sb.append("i:" + i);
}
// 伪代码:解锁操作
return sb.toString();
}
锁粗化的作用:如果检测到同一个对象执行了连续的加锁和解锁的操作,则会将这一系列操作合并成一个更大的锁,从而提升程序的执行效率。
1.2.4 自适应自旋锁
自旋锁是指通过自身循环,尝试获取锁的一种方式,伪代码实现如下:
public class SpinLockDemo {
// 现在的泛型装的是Thread,原子引用线程
AtomicReference<Thread> atomicReference = new AtomicReference<>();
public void myLock() {
// 获取当前进来的线程
Thread thread = Thread.currentThread();
System.out.println(Thread.currentThread().getName() + "\t come in ");
// 开始自旋,期望值是null,更新值是当前线程,如果是null,则更新为当前线程;否则自旋
while(!atomicReference.compareAndSet(null, thread)) {
System.out.println(Thread.currentThread().getName() + "正在自旋=====");
}
}
/**
* 解锁
*/
public void myUnLock() {
// 获取当前进来的线程
Thread thread = Thread.currentThread();
// 自己用完了后,把atomicReference变成null
atomicReference.compareAndSet(thread, null);
System.out.println(Thread.currentThread().getName() + "\t invoked myUnlock()");
}
}
自旋锁优点在于它避免一些线程的挂起和恢复操作,因为挂起线程和恢复线程都需要从用户态转入内核态,这个过程是比较慢的,所以通过自旋的方式可以一定程度上避免线程挂起和恢复所造成的性能开销。
但是,如果长时间自旋还获取不到锁,那么也会造成一定的cpu资源浪费,所以我们通常会给自旋设置一个固定的值来避免一直自旋的性能开销。然而对于 synchronized 关键字来说,它的自旋锁更加的“智能”,synchronized 中的自旋锁是自适应自旋锁。
【自适应自旋锁】 :线程自旋的次数不再是固定的值,而是一个动态改变的值,这个值会根据前一次自旋获取锁的状态来决定此次自旋的次数。比如上一次通过自旋成功获取到了锁,那么这次通过自旋也有可能会获取到锁,所以这次自旋的次数就会增多一些,而如果上一次通过自旋没有成功获取到锁,那么这次自旋可能也获取不到锁,所以为了避免资源的浪费,就会少循环或者不循环,以提高程序的执行效率。简单来说,如果线程自旋成功了,则下次自旋的次数会增多,如果失败,下次自旋的次数会减少。
二、 synchronized原理
synchronized 的语义底层是通过一个monitor的对象来完成
要理解 sychronized 首先要了解 对象头的MarkWord 和 管程Monitor,在 上文《多线程基础知识》《偏向锁/轻量级锁/重量级锁详解》中已经介绍过了。


Java 虚拟机中的同步(Synchronization)基于进入和退出管程(Monitor)对象实现, 无论是显式同步 (有明确的 monitorenter 和 monitorexit 指令,即同步代码块) 还是隐式同步都是如此。在 Java 语言中,同步用的最多的地方可能是被 synchronized 修饰的同步方法。同步方法 并不是由 monitorenter 和 monitorexit 指令来实现同步的,而是由方法调用指令读取运行时常量池中方法的 ACC_SYNCHRONIZED 标志来隐式实现的。
- 同步代码块:显式同步,有明确的 monitorenter 和 monitorexit 指令。
- 同步方法:隐式同步,由方法调用指令读取运行时常量池中方法的 ACC_SYNCHRONIZED 标志。
2.1 synchronized 代码块字节码
现在我们定义一个 synchronized 修饰的同步代码块,在代码块中操作共享变量i,如下:
public class SyncCodeBlock {
public int i;
public void syncTask(){
//同步代码库
synchronized (this){
i++;
}
}
}
编译上述代码并使用【javap -c -verbose ByteCodeTest.class】 反编译后得到字节码如下(这里我们省略一部分没有必要的信息):
也可以使用 IDEA 中的插件 【jclasslib Bytecode Viewer】,使用时直接选择 View --> Show Bytecode With jclasslib :
Classfile /Users/zejian/Downloads/Java8_Action/src/main/java/com/zejian/concurrencys/SyncCodeBlock.class
Last modified 2017-6-2; size 426 bytes
MD5 checksum c80bc322c87b312de760942820b4fed5
Compiled from "SyncCodeBlock.java"
public class com.zejian.concurrencys.SyncCodeBlock
minor version: 0
major version: 52
flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
//........省略常量池中数据
//构造函数
public com.zejian.concurrencys.SyncCodeBlock();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
LineNumberTable:
line 7: 0
//===========主要看看syncTask方法实现================
public void syncTask();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=3, locals=3, args_size=1
0: aload_0
1: dup
2: astore_1
3: monitorenter //注意此处,进入同步方法
4: aload_0
5: dup
6: getfield #2 // Field i:I
9: iconst_1
10: iadd
11: putfield #2 // Field i:I
14: aload_1
15: monitorexit //注意此处,退出同步方法
16: goto 24
19: astore_2
20: aload_1
21: monitorexit //注意此处,退出同步方法
22: aload_2
23: athrow
24: return
Exception table:
//省略其他字节码.......
}
SourceFile: "SyncCodeBlock.java"
我们主要关注字节码中的如下代码:
3: monitorenter //进入同步方法
//..........省略其他
15: monitorexit //退出同步方法
16: goto 24
//省略其他.......
21: monitorexit //退出同步方法
2.2 synchronized 方法字节码
方法级的同步是隐式,即无需通过字节码指令来控制的,它实现在方法调用和返回操作之中。JVM可以从方法常量池中的方法表结构(method_info Structure) 中的 ACC_SYNCHRONIZED 访问标志区分一个方法是否同步方法。
当方法调用时,调用指令将会 检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置,如果设置了,执行线程需要先竞争持有对象锁,即该对象对应的 monitor(虚拟机规范中用的是管程一词), 然后再执行方法,最后在方法执行完成(无论是正常完成还是非正常完成)时释放 monitor 。
在方法执行期间,执行线程持有了 monitor,其他任何线程都无法再获得同一个 monitor。如果一个同步方法执行期间抛出了异常,并且在方法内部无法处理此异常,那这个同步方法所持有的 monitor 将在异常抛到同步方法之外时自动释放。下面我们看看字节码层面如何实现:
public class SyncMethod {
public int i;
public synchronized void syncTask(){
i++;
}
}
使用javap反编译后的字节码如下:
Classfile /Users/zejian/Downloads/Java8_Action/src/main/java/com/zejian/concurrencys/SyncMethod.class
Last modified 2017-6-2; size 308 bytes
MD5 checksum f34075a8c059ea65e4cc2fa610e0cd94
Compiled from "SyncMethod.java"
public class com.zejian.concurrencys.SyncMethod
minor version: 0
major version: 52
flags: ACC_PUBLIC, ACC_SUPER
Constant pool;
//省略没必要的字节码
//==================syncTask方法======================
public synchronized void syncTask();
descriptor: ()V
//方法标识ACC_PUBLIC代表public修饰,ACC_SYNCHRONIZED指明该方法为同步方法
flags: ACC_PUBLIC, ACC_SYNCHRONIZED
Code:
stack=3, locals=1, args_size=1
0: aload_0
1: dup
2: getfield #2 // Field i:I
5: iconst_1
6: iadd
7: putfield #2 // Field i:I
10: return
LineNumberTable:
line 12: 0
line 13: 10
}
SourceFile: "SyncMethod.java"
从字节码中可以看出,synchronized 修饰的方法并没有 monitorenter 指令和 monitorexit 指令,取得代之的是 ACC_SYNCHRONIZED 标识,该标识指明了该方法是一个同步方法,JVM通过该 ACC_SYNCHRONIZED 访问标志来辨别一个方法是否声明为同步方法,从而执行相应的同步调用。
2.3 synchronized底层源码——monitorenter指令
1. JVM源码下载 http://openjdk.java.net/ Mercurial --> jdk8 --> hotspot --> zip
2. IDE(Clion)下载 https://www.jetbrains.com/
Monitor:openjdk\hotspot\src\share\vm\runtime\objectMonitor.hppMarkWord:openjdk\hotspot\src\share\vm\oops\markOop.hppmonitorenter|exit指令:openjdk\hotspot\\src\share\vm\interpreter\interpreterRuntime.cpp- 偏向锁:
openjdk\hotspot\src\share\vm\runtime\biasedLocking.cpp
在虛拟机执行到 monitorenter 指令时,首先要尝试获取对象的锁,即获取该对象对应的 monitor 的所有权。源码中会调用InterpreterRuntime.cpp (位于:src/share/vm/interpreter/interpreterRuntime.cpp) 的 InterpreterRuntime::monitorenter 函数。具体代码可参见HotSpot源码:
#InterpreterRuntime.cpp
IRT_ENTRY_NO_ASYNC(void, InterpreterRuntime::monitorenter(JavaThread* thread, BasicObjectLock* elem))
#ifdef ASSERT
thread->last_frame().interpreter_frame_verify_monitor(elem);
#endif
if (PrintBiasedLockingStatistics) {
Atomic::inc(BiasedLocking::slow_path_entry_count_addr());
}
Handle h_obj(thread, elem->obj());
assert(Universe::heap()->is_in_reserved_or_null(h_obj()),
"must be NULL or an object");
//是否使用偏向锁
if (UseBiasedLocking) {
// Retry fast entry if bias is revoked to avoid unnecessary inflation
ObjectSynchronizer::fast_enter(h_obj, elem->lock(), true, CHECK);
} else {//绕过偏向锁,直接进入轻量级锁
ObjectSynchronizer::slow_enter(h_obj, elem->lock(), CHECK);
}
assert(Universe::heap()->is_in_reserved_or_null(elem->obj()),
"must be NULL or an object");
#ifdef ASSERT
thread->last_frame().interpreter_frame_verify_monitor(elem);
#endif
IRT_END
2.3.1 ObjectSynchronizer::fast_enter 走偏向锁的逻辑
如果支持偏向锁,则执行 ObjectSynchronizer::fast_enter 走偏向锁的逻辑,源码实现在 synchronizer.cpp文件中,代码如下:
void ObjectSynchronizer::fast_enter(Handle obj, BasicLock* lock, bool attempt_rebias, TRAPS) {
//判断是否开启了偏向锁
if (UseBiasedLocking) {
//如果不处于全局安全点
if (!SafepointSynchronize::is_at_safepoint()) {
//通过`revoke_and_rebias`这个函数尝试获取偏向锁
BiasedLocking::Condition cond = BiasedLocking::revoke_and_rebias(obj, attempt_rebias, THREAD);
//如果是撤销与重偏向直接返回
if (cond == BiasedLocking::BIAS_REVOKED_AND_REBIASED) {
return;
}
} else {//如果在安全点,撤销偏向锁
assert(!attempt_rebias, "can not rebias toward VM thread");
BiasedLocking::revoke_at_safepoint(obj);
}
assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
}
slow_enter (obj, lock, THREAD) ;
}
流程如下:
- 再次检查偏向锁是否开启,如果未开启:
- 当处于不安全点时,通过 revoke_and_rebias() 尝试获取偏向锁,如果成功则直接返回,如果失败则进入轻量级锁获取过程。revoke_and_rebias() 这个偏向锁的获取逻辑在 biasedLocking.cpp中。
- 当处于安全点时,撤销偏向锁。
- 如果偏向锁未开启,则进入 slow_enter() 获取轻量级锁的流程。
2.3.1.1 BiasedLocking::revoke_and_rebias 函数——偏向锁获取逻辑
BiasedLocking::Condition BiasedLocking::revoke_and_rebias(Handle obj, bool attempt_rebias, TRAPS) {
assert(!SafepointSynchronize::is_at_safepoint(), "must not be called while at safepoint");
markOop mark = obj->mark(); //获取锁对象的对象头
//判断mark是否为可偏向状态,即mark的偏向锁标志位为1,锁标志位为 01,线程id为null
if (mark->is_biased_anonymously() && !attempt_rebias) {
//这个分支是进行对象的hashCode计算时会进入,在一个非全局安全点进行偏向锁撤销
markOop biased_value = mark;
//创建一个非偏向的markword
markOop unbiased_prototype = markOopDesc::prototype()->set_age(mark->age());
//Atomic:cmpxchg_ptr是CAS操作,通过cas重新设置偏向锁状态
markOop res_mark = (markOop) Atomic::cmpxchg_ptr(unbiased_prototype, obj->mark_addr(), mark);
if (res_mark == biased_value) {//如果CAS成功,返回偏向锁撤销状态
return BIAS_REVOKED;
}
} else if (mark->has_bias_pattern()) {//如果锁对象为可偏向状态(biased_lock:1, lock:01,不管线程id是否为空),尝试重新偏向
Klass* k = obj->klass();
markOop prototype_header = k->prototype_header();
//如果已经有线程对锁对象进行了全局锁定,则取消偏向锁操作
if (!prototype_header->has_bias_pattern()) {
markOop biased_value = mark;
//CAS 更新对象头markword为非偏向锁
markOop res_mark = (markOop) Atomic::cmpxchg_ptr(prototype_header, obj->mark_addr(), mark);
assert(!(*(obj->mark_addr()))->has_bias_pattern(), "even if we raced, should still be revoked");
return BIAS_REVOKED; //返回偏向锁撤销状态
} else if (prototype_header->bias_epoch() != mark->bias_epoch()) {
//如果偏向锁过期,则进入当前分支
if (attempt_rebias) {//如果允许尝试获取偏向锁
assert(THREAD->is_Java_thread(), "");
markOop biased_value = mark;
markOop rebiased_prototype = markOopDesc::encode((JavaThread*) THREAD, mark->age(), prototype_header->bias_epoch());
//通过CAS 操作, 将本线程的 ThreadID 、时间错、分代年龄尝试写入对象头中
markOop res_mark = (markOop) Atomic::cmpxchg_ptr(rebiased_prototype, obj->mark_addr(), mark);
if (res_mark == biased_value) { //CAS成功,则返回撤销和重新偏向状态
return BIAS_REVOKED_AND_REBIASED;
}
} else {//不尝试获取偏向锁,则取消偏向锁
//通过CAS操作更新分代年龄
markOop biased_value = mark;
markOop unbiased_prototype = markOopDesc::prototype()->set_age(mark->age());
markOop res_mark = (markOop) Atomic::cmpxchg_ptr(unbiased_prototype, obj->mark_addr(), mark);
if (res_mark == biased_value) { //如果CAS操作成功,返回偏向锁撤销状态
return BIAS_REVOKED;
}
}
}
}
...//省略
}
2.3.1.2 BiasedLocking::revoke_at_safepoint——偏向锁撤销逻辑
当到达一个全局安全点时,这时会根据偏向锁的状态来判断是否需要撤销偏向锁,调用 BiasedLocking::revoke_at_safepoint 函数,这个方法也是在 BiasedLocking.cpp 中定义的,具体实现如下:
void BiasedLocking::revoke_at_safepoint(Handle h_obj) {
assert(SafepointSynchronize::is_at_safepoint(), "must only be called while at safepoint");
oop obj = h_obj();
//更新撤销偏向锁计数,并返回偏向锁撤销次数和偏向次数
HeuristicsResult heuristics = update_heuristics(obj, false);
if (heuristics == HR_SINGLE_REVOKE) {//可偏向且未达到批量处理的阈值(下面会单独解释)
revoke_bias(obj, false, false, NULL); //撤销偏向锁
} else if ((heuristics == HR_BULK_REBIAS) ||
(heuristics == HR_BULK_REVOKE)) {//如果是多次撤销或者多次偏向
//批量撤销
bulk_revoke_or_rebias_at_safepoint(obj, (heuristics == HR_BULK_REBIAS), false, NULL);
}
clean_up_cached_monitor_info();
}
偏向锁的释放,需要等待全局安全点(在这个时间点上没有正在执行的字节码),首先暂停拥有偏向锁的线程,然后检查持有偏向锁的线程是否还活着,如果线程不处于活动状态,则将对象头设置成无锁状态(ThreadID设置为NULL)。如果线程仍然活着,则会升级为轻量级锁,遍历偏向对象的所记录。栈帧中的锁记录和对象头的Mark Word要么重新偏向其他线程,要么恢复到无锁,或者标记对象不适合作为偏向锁。最后唤醒暂停的线程。
在上一节我们知道,JVM内部为每个类维护了一个偏向锁撤销计数器,对偏向锁撤销进行计数,当这个值达到指定阈值时,JVM会认为这个类的偏向锁有问题,需要重新偏向(rebias),对所有属于这个类的对象进行重偏向的操作成为 批量重偏向(bulk rebias)。在做bulk rebias时,会对这个类的epoch的值做自增,这个 epoch 会存储在对象头中的 epoch 字段。
判断这个对象是否获得偏向锁的条件是:
1. 对象头中markword的锁状态标志位为101;
2. ThreadID和当前线程id相等
3. 锁对象头中 mark word 的 epoch 字段和方法区 InstanceClass 中 _protype_header 的epoch值相同。如果epoch的值不一样,说明该对象的偏向锁已经无效了。
2.3.2 ObjectSynchronizer::slow_enter 走轻量级锁的逻辑
如果不支持偏向锁,则执行 ObjectSynchronizer::slow_enter 走轻量级锁的逻辑,该方法同样位于 synchronizer.cpp 文件中,代码如下:
void ObjectSynchronizer::slow_enter(Handle obj, BasicLock* lock, TRAPS) {
markOop mark = obj->mark();
assert(!mark->has_bias_pattern(), "should not see bias pattern here");
if (mark->is_neutral()) {//如果当前是无锁状态,直接加轻量级锁
//直接把markword保存到栈帧中BasicLock(LockRecord)对象的_displaced_header中
lock->set_displaced_header(mark);
//通过CAS将mark word更新为指向栈帧中BasicLock(LockRecord)对象的指针,更新成功表示获得了轻量级锁
if (mark == (markOop) Atomic::cmpxchg_ptr(lock, obj()->mark_addr(), mark)) {
TEVENT (slow_enter: release stacklock) ;
return ;
}
// Fall through to inflate() ...
}
//如果markword处于加锁状态、且markword中的ptr指针指向当前线程的栈帧,表示为重入操作,不需要争抢锁
else
if (mark->has_locker() && THREAD->is_lock_owned((address)mark->locker())) {
assert(lock != mark->locker(), "must not re-lock the same lock");
assert(lock != (BasicLock*)obj->mark(), "don't relock with same BasicLock");
lock->set_displaced_header(NULL);
return;
}
#if 0
// The following optimization isn't particularly useful.
if (mark->has_monitor() && mark->monitor()->is_entered(THREAD)) {
lock->set_displaced_header (NULL) ;
return ;
}
#endif
//代码执行到这里,说明有多个线程竞争轻量级锁,轻量级锁通过`inflate`进行膨胀升级为重量级锁
lock->set_displaced_header(markOopDesc::unused_mark());
ObjectSynchronizer::inflate(THREAD, obj())->enter(THREAD);
}
简单整理轻量级锁的获取逻辑:
- 如果markword处于无锁状态(001):
- 直接把markword保存到栈帧中BasicLock(LockRecord)对象的_displaced_header中;
- 通过CAS将markword更新为指向栈帧中BasicLock(LockRecord)对象的指针,更新成功表示获得了轻量级锁;
- 如果当前markword处于加锁状态(000),且mark中的 ptr 指针指向当前线程的栈帧(锁重入),则执行同步代码;否则说明有多个线程竞争轻量级锁,轻量级锁需要膨胀升级为重量级锁。
2.3.3 轻量级锁膨胀为重量级锁——ObjectSynchronizer::inflate 函数
回顾之前的分析:
- 偏向锁升级为轻量级锁时要修改Mark Word,使之指向 Lock Record;
- 轻量级锁升级为重量级锁时也需要修改 Mark Word,使之指向 ObjectMonitor。
而创建/获取 ObjectMonitor 对象的过程即是锁的膨胀过程。
我们继续跟进 ObjectSynchronizer::inflate 函数,该方法描述了轻量级锁膨胀为重量级锁的过程(创建/获取 ObjectMonitor 对象的过程),源码如下:
#synchronizer.cpp
ObjectMonitor * ATTR ObjectSynchronizer::inflate (Thread * Self, oop object) {
...
//死循环,直到获取到ObjectMonitor为止
for (;;) {
//取出Mark Word
const markOop mark = object->mark() ;
//如果是重量级锁
if (mark->has_monitor()) {
//是重量级锁,说明肯定已经有现成的ObjectMonitor,直接用就好了
ObjectMonitor * inf = mark->monitor() ;
return inf ;
}
//正在膨胀的时候
if (mark == markOopDesc::INFLATING()) {
//继续循环,需要等待膨胀完成
continue ;
}
//如果当前是轻量级锁
if (mark->has_locker()) {
//分配ObjectMonitor对象
ObjectMonitor * m = omAlloc (Self) ;
//初始化一些参数
m->Recycle();
m->_Responsible = NULL ;
m->OwnerIsThread = 0 ;
m->_recursions = 0 ;
m->_SpinDuration = ObjectMonitor::Knob_SpinLimit ; // Consider: maintain by type/class
//尝试将Mark Word更改为膨胀状态,此时Mark Word 全是0 --------->(1)
//可能会有多线程走到这,因此用CAS
markOop cmp = (markOop) Atomic::cmpxchg_ptr (markOopDesc::INFLATING(), object->mark_addr(), mark) ;
if (cmp != mark) {
//修改失败,继续循环
omRelease (Self, m, true) ;
continue ; // Interference -- just retry
}
//若是修改成功,则取出之前轻量级锁存储的Mark Word
markOop dmw = mark->displaced_mark_helper() ;
//将Mark Word 搬到ObjectMonitor的_header字段里
m->set_header(dmw) ;
//_owner指向Lock Record,也就是设置锁的持有者是Lock Record------->(2)
m->set_owner(mark->locker());
//指向对象头
m->set_object(object);
//将Mark Word 指向ObjectMonitor------->(3)
object->release_set_mark(markOopDesc::encode(m));
...
//成功,则返回ObjectMonitor 对象
return m ;
}
//无锁状态
ObjectMonitor * m = omAlloc (Self) ;
//初始化一些参数
m->Recycle();
//直接记录mark
m->set_header(mark);
//_owner为空-------------------->(4)
m->set_owner(NULL);
m->set_object(object);
m->OwnerIsThread = 1 ;
m->_recursions = 0 ;
m->_Responsible = NULL ;
m->_SpinDuration = ObjectMonitor::Knob_SpinLimit ; // consider: keep metastats by type/class
//将Mark Word修改为指向ObjectMonitor的指针-------------------->(5)
if (Atomic::cmpxchg_ptr (markOopDesc::encode(m), object->mark_addr(), mark) != mark) {
...
//失败,则重新尝试
continue ;
}
...
//成功,则返回ObjectMonitor 对象
return m ;
}
}
上述代码即为简化过的膨胀流程,标注了5个重点:
- 如果当前锁是轻量级锁,说明有线程正在持有该锁,尝试CAS修改锁为膨胀状态。
- _owner不指向任何线程,指向的是Lock Reocrd,后续会有相应的判断。
- 轻量级锁时 MarkWord 存储着指向 Lock Record 的指针,而此时变为指向重量级锁的指针,也就是指向 ObjectMonitor 的指针。此处是单线程操作,因此可以直接设置。
- 如果当前锁是无锁状态,将_owner置空。
- CAS尝试将 Mark Word 指向ObjectMonitor。

2.3.4 重量级锁加锁过程——ObjectMonitor::enter 函数
在调用 ObjectSynchronizer::inflate 函数完成膨胀,获取 ObjectMonitor 对象后,会调用 ObjectMonitor::enter(位于:src/share/vm/runtime/objectMonitor.cpp)函数完成重量级锁的加锁,源码如下:
2.3.4.1 ObjectMonitor::enter——初次尝试加锁(monitor竞争)
初次获取锁在 ObjectMonitor::enter 函数的实现:
#ObjectMonitor.cpp
void ATTR ObjectMonitor::enter(TRAPS) {
//当前线程
Thread * const Self = THREAD ;
void * cur ;
//尝试CAS修改_owner字段为当前线程,也就是尝试获取锁
cur = Atomic::cmpxchg_ptr (Self, &_owner, NULL) ;
if (cur == NULL) {
//修改成功,则获取了重量级锁
return ;
}
//以下都是CAS失败后的处理
//如果当前_owner值为当前线程,则认为是重入了该锁
if (cur == Self) {
//重入次数+1,成功获取了锁
_recursions ++ ;
return ;
}
//_owner值为Lock Record,说明当前线程是之前轻量级锁的持有者
if (Self->is_lock_owned ((address)cur)) {
//重入次数为1次
_recursions = 1 ;
//改为当前线程
_owner = Self ;
OwnerIsThread = 1 ;
return ;
}
...
{
...
for (;;) {
//没有获取到锁,则执行该函数
EnterI (THREAD) ;
...
_recursions = 0 ;
_succ = NULL ;
exit (false, Self) ;
jt->java_suspend_self();
}
}
}
由上可知,enter(xx) 函数主要做了如下事情:
- 先CAS尝试修改 ObjectMonitor 的 _owner 字段,会有几种结果:
- 1、锁没被其它线程占用,当前线程成功获取锁。
- 2、锁被当前线程占用,当前线程重入该锁,获取锁成功,重入次数_recursions++。
- 3、锁被 LockRecord 占用(轻量级锁),而LockRecord又属于当前线程,属于重入,重入次数_recursions为1。
- 4、以上条件都不满足,调用 EnterI() 函数。

2.3.4.2 ObjectMonitor::EnterI()——再次尝试加锁(monitor等待)
初次获取锁失败后,会走到下面的流程,也就是 ObjectMonitor::EnterI 函数的实现(位于:src/share/vm/runtime/ObjectMonitor.cpp):
#ObjectMonitor.cpp
void ATTR ObjectMonitor::EnterI (TRAPS) {
//当前线程
Thread * Self = THREAD ;
//尝试加锁----------->(1)
if (TryLock (Self) > 0) {
return ;
}
//尝试自旋加锁----------->(2)
if (TrySpin (Self) > 0) {
return ;
}
//构造ObjectWaiter 节点
ObjectWaiter node(Self) ;
//挂起/唤醒线程重置参数
Self->_ParkEvent->reset() ;
//前驱节点为无效节点
node._prev = (ObjectWaiter *) 0xBAD ;
//当前节点状态为CXQ,也就是说节点在_cxq队列里
node.TState = ObjectWaiter::TS_CXQ ;
ObjectWaiter * nxt ;
for (;;) {
node._next = nxt = _cxq ;
//将节点插入_cxq队列的头----------->(3)
if (Atomic::cmpxchg_ptr (&node, &_cxq, nxt) == nxt) break ;
//尝试获取锁----------->(4)
if (TryLock (Self) > 0) {
return ;
}
}
...
for (;;) {
//再次尝试获取锁----------->(5)
if (TryLock (Self) > 0) break ;
if ((SyncFlags & 2) && _Responsible == NULL) {
Atomic::cmpxchg_ptr (Self, &_Responsible, NULL) ;
}
//挂起线程----------->(6)
if (_Responsible == Self || (SyncFlags & 1)) {
//挂起有超时时间
Self->_ParkEvent->park ((jlong) RecheckInterval) ;
} else {
//挂起没有超时时间
Self->_ParkEvent->park() ;
}
//唤醒后再次获取锁,成功则退出循环----------->(7)
if (TryLock(Self) > 0) break ;
//...还是一些自旋策略
}
//将节点从_cxq或_EntryList里移除----------->(8)
UnlinkAfterAcquire (Self, &node) ;
...
return ;
}

ObjectMonitor::EnterI 函数主要做了如下事情:
- TryLock (Self) 尝试加锁(通过CAS将锁对象的 ObjectMonitor 内的 _owner 字段设置为当前线程);
- TrySpin (Self) 尝试自旋加锁(TrySpin里多次调用TryLock,次数是10次;源码里指出经验值20-100可能最佳);
- 如果仍然没有获取到锁,进入死循环,直到插入cxq队列成功或者获取了锁:
- 将该线程封装成一个 ObjectWaiter 对象 CAS 插入到 cxq(单向链表)队列的队首,修改 _cxq 指向当前节点,成功则break跳出循环。
- 插入队列失败,再次调用 TryLock (Self) 尝试获取锁,成功则直接return结束。
- 进入下一个死循环,先调用 TryLock (Self) 尝试获取锁;
- 若仍旧获取锁失败,则线程放弃获取锁的动作,调用 park() 将自己挂起,线程阻塞于此处,等待别的线程唤醒它。
- 当某个线程唤醒在(5)被挂起的线程后,被唤醒的线程立即调用 TryLock (Self) 再次尝试获取锁,如果还是失败了,则继续回到(4)的死循环。
- 获取锁成功后,因为前边已经加入到队列了,因此需要将节点从队列(cxq/EntryList)移除。

2.4 synchronized底层源码——monitorexit指令
在虛拟机执行到 monitorexit 指令释放锁时,源码中会调用InterpreterRuntime.cpp (位于:src/share/vm/interpreter/interpreterRuntime.cpp) 的 InterpreterRuntime::monitorexit 函数。具体代码可参见HotSpot源码:
#InterpreterRuntime.cpp
IRT_ENTRY_NO_ASYNC(void, InterpreterRuntime::monitorexit(JavaThread* thread, BasicObjectLock* elem))
#ifdef ASSERT
thread->last_frame().interpreter_frame_verify_monitor(elem);
#endif
Handle h_obj(thread, elem->obj());
assert(Universe::heap()->is_in_reserved_or_null(h_obj()),
"must be NULL or an object");
if (elem == NULL || h_obj()->is_unlocked()) {
THROW(vmSymbols::java_lang_IllegalMonitorStateException());
}
ObjectSynchronizer::slow_exit(h_obj(), elem->lock(), thread);
// Free entry. This must be done here, since a pending exception might be installed on
// exit. If it is not cleared, the exception handling code will try to unlock the monitor again.
elem->set_obj(NULL);
#ifdef ASSERT
thread->last_frame().interpreter_frame_verify_monitor(elem);
#endif
IRT_END
这段代码中主要是通过 ObjectSynchronizer::slow_exit 来执行,具体实现如下:
void ObjectSynchronizer::slow_exit(oop object, BasicLock* lock, TRAPS) {
fast_exit (object, lock, THREAD) ;
}
ObjectSynchronizer::fast_exit的代码如下:
void ObjectSynchronizer::fast_exit(oop object, BasicLock* lock, TRAPS) {
assert(!object->mark()->has_bias_pattern(), "should not see bias pattern here");
// if displaced header is null, the previous enter is recursive enter, no-op
markOop dhw = lock->displaced_header(); //获取锁对象中的对象头
markOop mark ;
if (dhw == NULL) {
// Recursive stack-lock.
// Diagnostics -- Could be: stack-locked, inflating, inflated.
mark = object->mark() ;
assert (!mark->is_neutral(), "invariant") ;
if (mark->has_locker() && mark != markOopDesc::INFLATING()) {
assert(THREAD->is_lock_owned((address)mark->locker()), "invariant") ;
}
if (mark->has_monitor()) {
ObjectMonitor * m = mark->monitor() ;
assert(((oop)(m->object()))->mark() == mark, "invariant") ;
assert(m->is_entered(THREAD), "invariant") ;
}
return ;
}
mark = object->mark() ; //获取线程栈帧中锁记录(LockRecord)中的markword
// If the object is stack-locked by the current thread, try to
// swing the displaced header from the box back to the mark.
if (mark == (markOop) lock) {
assert (dhw->is_neutral(), "invariant") ;
//通过CAS尝试将Displaced Mark Word替换回对象头,如果成功,表示锁释放成功。
if ((markOop) Atomic::cmpxchg_ptr (dhw, object->mark_addr(), mark) == mark) {
TEVENT (fast_exit: release stacklock) ;
return;
}
}
//锁膨胀,调用重量级锁的释放锁方法
ObjectSynchronizer::inflate(THREAD, object)->exit (true, THREAD) ;
}
2.4.1 重量级锁释放过程
上面分析了加锁的过程,它有两种结果:
- 成功获取锁,那么可以执行临界区代码。
- 获取锁失败,挂起等待别人唤醒。
关于2思考一个问题:是谁唤醒了它,如何唤醒的?由下源码可知:当前占有锁的线程释放锁后会唤醒阻塞等待锁的线程。
先来看看1,线程执行完临界区代码后需要释放锁,偏向锁和轻量级锁的释放上篇文章已经分析:若是释放失败,则会走到重量级锁的释放流程。重量级锁的释放流程,也就是 ObjectMonitor::exit 函数的实现(位于:src/share/vm/runtime/ObjectMonitor.cpp):
#ObjectMonitor.cpp
void ATTR ObjectMonitor::exit(bool not_suspended, TRAPS) {
Thread * Self = THREAD ;
//释放锁的线程不一定是重量级锁的获得者-------->(1)
if (THREAD != _owner) {
if (THREAD->is_lock_owned((address) _owner)) {
//释放锁的线程是轻量级锁的获得者,先占用锁
_owner = THREAD ;
} else {
//异常情况
return;
}
}
if (_recursions != 0) {
//是重入锁,简单标记后退出
_recursions--;
return ;
}
...
for (;;) {
if (Knob_ExitPolicy == 0) {
//默认走这里
//释放锁,别的线程可以抢占了
OrderAccess::release_store_ptr (&_owner, NULL) ; // drop the lock
OrderAccess::storeload() ; // See if we need to wake a successor
//如果没有线程在_cxq/_EntryList等待,则直接退出
if ((intptr_t(_EntryList)|intptr_t(_cxq)) == 0 || _succ != NULL) {
TEVENT (Inflated exit - simple egress) ;
return ;
}
//有线程在等待,再把之前释放的锁拿回来
if (Atomic::cmpxchg_ptr (THREAD, &_owner, NULL) != NULL) {
//若是失败,说明被人抢占了,直接退出
return ;
}
} else {
...
}
ObjectWaiter * w = NULL ;
int QMode = Knob_QMode ;
//此处省略代码
//根据QMode不同,选不同的策略,主要是操作_cxq和_EntryList的方式不同
//默认QMode=0
w = _EntryList ;
if (w != NULL) {
//_EntryList不为空,则释放锁---------(2)
ExitEpilog (Self, w) ;
return ;
}
//_EntryList 为空,则看_cxq有没有数据
w = _cxq ;
if (w == NULL) continue ;//没有继续循环
for (;;) {
//将_cxq头节点置空
ObjectWaiter * u = (ObjectWaiter *) Atomic::cmpxchg_ptr (NULL, &_cxq, w) ;
if (u == w) break ;
w = u ;
}
if (QMode == 1) {
...
} else {
// QMode == 0 or QMode == 2
//_EntryList指向_cxq
_EntryList = w ;
ObjectWaiter * q = NULL ;
ObjectWaiter * p ;
//该循环的目的是为了将_EntryList里的节点前驱连接起来---------(3)
for (p = w ; p != NULL ; p = p->_next) {
guarantee (p->TState == ObjectWaiter::TS_CXQ, "Invariant") ;
//改为ENTER状态
p->TState = ObjectWaiter::TS_ENTER ;
p->_prev = q ;
q = p ;
}
}
w = _EntryList ;
if (w != NULL) {
//释放锁---------(4)
ExitEpilog (Self, w) ;
return ;
}
}
}
当线程释放锁时,会从 cxq 或 EntryList 中挑选一个线程唤醒(根据「唤醒策略」,默认从 EntryList 的 Head 取),被选中的线程叫做 Heir presumptive (即假定继承人),就是上图中的 OnDeck(Ready Thread),假定继承人被唤醒后会尝试获得锁,但 synchronized 是非公平的,所以假定继承人不一定能获得锁(这也是它叫"假定"继承人的原因)。
- 如果 _owner 不是当前线程(判断当前是不是持有锁的线程):
- 若当前线程是之前持有轻量级锁的线程(由轻量级锁膨胀后还没调用过 enter 方法,此时_owner会是指向 Lock Record 的指针),则_owner改为指向当前线程,然后继续执行后面代码。
- 否则异常情况,即当前不是持有锁的线程,抛出异常。
- 如果_recursions (重入计数器) -1 后还不为0(还是重入),则返回继续执行程序代码。
- 如果_recursions (重入计数器) -1 后为0,则释放锁(即设置owner为null),这个时刻其他的线程能获取到锁。
- 如果当前没有线程在_cxq/_EntryList等待,则直接退出,因为不需要唤醒其他线程;或者如果 succ不为null,代表当前已经有个"醒着的"继承人线程OnDeck,那当前线程不需要唤醒任何线程,直接退出。
- 根据 QMode 的不同,会执行不同的「唤醒策略」(QMode默认为0)
- QMode = 2且 cxq 非空:取 cxq 队列队首的 ObjectWaiter 对象,调用 ExitEpilog() 方法,然后立即返回。【ExitEpilog (Self, w) :释放锁,将_owner置空;然后唤醒节点里ObjectWaiter对象封装的线程】
- QMode = 3且 cxq 非空:把 cxq 队列插入到 EntryList 的 尾部;继续往下执行。
- QMode = 4且 cxq 非空:把 cxq 队列插入到 EntryList 的头部;继续往下执行。
- QMode = 0(默认):暂时什么都不做,继续往下(QMode默认是0);只有QMode=2的时候会提前返回,等于0、3、4的时候都会继续往下执行解锁流程:
- 如果 EntryList 的首元素非空,就取出来调用 ExitEpilog() 方法,该方法会唤醒 ObjectWaiter 对象的线程(在 EnterI() 方法中调用 park() 挂起的线程),然后立即返回;
- 如果 EntryList 的首元素为空,就将 cxq 的所有元素放入到 EntryList 中,然后再从 EntryList 中取出来队首元素执行 ExitEpilog 方法,然后立即返回;
Qmode=0(默认策略) 的判断逻辑就是先判断 Entrylist 是否为空:如果不为空,则取出第一个唤醒;如果为空再从 cxq 里面获取第一个唤醒。
Object#notify 方法唤醒线程后,线程会从 waitSet 移动到 EntryList ,线程最开始获取失败锁时总是在 _cxq 中,后再往 EntryList 中移动,所以 notify() 唤醒的线程会比普通线程获取锁的线程前执行。

1120



被折叠的 条评论
为什么被折叠?



