多线程synchronized实现原理分析

作者&＃xff1a;EnjoyMoving&＃xff0c;转自&＃xff1a;https://zhuanlan.zhihu.com/p/29866981

锁的内存语义

synchronized的底层是使用操作系统的mutex lock实现的。

• 内存可见性&＃xff1a; 同步块的可见性是由“如果对一个变量执行lock操作&＃xff0c;将会清空工作内存中此变量的值&＃xff0c;在执行引擎使用这个变量前需要重新执行load或assign操作初始化变量的值”、“对一个变量执行unlock操作之前&＃xff0c;必须先把此变量同步回主内存中&＃xff08;执行store和write操作&＃xff09;”这两条规则获得的。
• 操作原子性&＃xff1a; 持有同一个锁的两个同步块只能串行地进入

锁的内存语义&＃xff1a;

• 当线程释放锁时&＃xff0c;JMM会把该线程对应的本地内存中的共享变量刷新到主内存中
• 当线程获取锁时&＃xff0c;JMM会把该线程对应的本地内存置为无效。从而使得被监视器保护的临界区代码必须从主内存中读取共享变量

锁释放和锁获取的内存语义&＃xff1a;

• 线程A释放一个锁&＃xff0c;实质上是线程A向接下来将要获取这个锁的某个线程发出了&＃xff08;线程A对共享变量所做修改的&＃xff09;消息。
• 线程B获取一个锁&＃xff0c;实质上是线程B接收了之前某个线程发出的&＃xff08;在释放这个锁之前对共享变量所做修改的&＃xff09;消息。
• 线程A释放锁&＃xff0c;随后线程B获取这个锁&＃xff0c;这个过程实质上是线程A通过主内存向线程B发送消息

synchronized锁

synchronized用的锁是存在Java对象头里的。

JVM基于进入和退出Monitor对象来实现方法同步和代码块同步。代码块同步是使用monitorenter和monitorexit指令实现的&＃xff0c;monitorenter指令是在编译后插入到同步代码块的开始位置&＃xff0c;而monitorexit是插入到方法结束处和异常处。任何对象都有一个monitor与之关联&＃xff0c;当且一个monitor被持有后&＃xff0c;它将处于锁定状态。

根据虚拟机规范的要求&＃xff0c;在执行monitorenter指令时&＃xff0c;首先要去尝试获取对象的锁&＃xff0c;如果这个对象没被锁定&＃xff0c;或者当前线程已经拥有了那个对象的锁&＃xff0c;把锁的计数器加1&＃xff1b;相应地&＃xff0c;在执行monitorexit指令时会将锁计数器减1&＃xff0c;当计数器被减到0时&＃xff0c;锁就释放了。如果获取对象锁失败了&＃xff0c;那当前线程就要阻塞等待&＃xff0c;直到对象锁被另一个线程释放为止。

注意两点&＃xff1a;

1、synchronized同步快对同一条线程来说是可重入的&＃xff0c;不会出现自己把自己锁死的问题&＃xff1b;

2、同步块在已进入的线程执行完之前&＃xff0c;会阻塞后面其他线程的进入。

Mutex Lock

监视器锁&＃xff08;Monitor&＃xff09;本质是依赖于底层的操作系统的Mutex Lock&＃xff08;互斥锁&＃xff09;来实现的。每个对象都对应于一个可称为" 互斥锁" 的标记&＃xff0c;这个标记用来保证在任一时刻&＃xff0c;只能有一个线程访问该对象。

互斥锁&＃xff1a;用于保护临界区&＃xff0c;确保同一时间只有一个线程访问数据。对共享资源的访问&＃xff0c;先对互斥量进行加锁&＃xff0c;如果互斥量已经上锁&＃xff0c;调用线程会阻塞&＃xff0c;直到互斥量被解锁。在完成了对共享资源的访问后&＃xff0c;要对互斥量进行解锁。

mutex的工作方式&＃xff1a;

• 1. 申请mutex
• 2. 如果成功&＃xff0c;则持有该mutex
• 3. 如果失败&＃xff0c;则进行spin自旋. spin的过程就是在线等待mutex, 不断发起mutex gets, 直到获得mutex或者达到spin_count限制为止
• 4. 依据工作模式的不同选择yiled还是sleep
• 5. 若达到sleep限制或者被主动唤醒或者完成yield, 则重复1)~4)步&＃xff0c;直到获得为止

由于Java的线程是映射到操作系统的原生线程之上的&＃xff0c;如果要阻塞或唤醒一条线程&＃xff0c;都需要操作系统来帮忙完成&＃xff0c;这就需要从用户态转换到核心态中&＃xff0c;因此状态转换需要耗费很多的处理器时间。所以synchronized是Java语言中的一个重量级操作。在JDK1.6中&＃xff0c;虚拟机进行了一些优化&＃xff0c;譬如在通知操作系统阻塞线程之前加入一段自旋等待过程&＃xff0c;避免频繁地切入到核心态中&＃xff1a;

synchronized与java.util.concurrent包中的ReentrantLock相比&＃xff0c;由于JDK1.6中加入了针对锁的优化措施&＃xff08;见后面&＃xff09;&＃xff0c;使得synchronized与ReentrantLock的性能基本持平。ReentrantLock只是提供了synchronized更丰富的功能&＃xff0c;而不一定有更优的性能&＃xff0c;所以在synchronized能实现需求的情况下&＃xff0c;优先考虑使用synchronized来进行同步。

Java对象头

在运行期间&＃xff0c;Mark Word里存储的数据会随着锁标志位的变化而变化&＃xff0c;以32位的JDK为例&＃xff1a;

锁优化

偏向锁、轻量级锁、重量级锁

synchronized是通过对象内部的一个叫做监视器锁&＃xff08;monitor&＃xff09;来实现的&＃xff0c;监视器锁本质又是依赖于底层的操作系统的Mutex Lock&＃xff08;互斥锁&＃xff09;来实现的。而操作系统实现线程之间的切换需要从用户态转换到核心态&＃xff0c;这个成本非常高&＃xff0c;状态之间的转换需要相对比较长的时间&＃xff0c;这就是为什么synchronized效率低的原因。因此&＃xff0c;这种依赖于操作系统Mutex Lock所实现的锁我们称之为“重量级锁”。

Java SE 1.6为了减少获得锁和释放锁带来的性能消耗&＃xff0c;引入了“偏向锁”和“轻量级锁”&＃xff1a;锁一共有4种状态&＃xff0c;级别从低到高依次是&＃xff1a;无锁状态、偏向锁状态、轻量级锁状态和重量级锁状态。锁可以升级但不能降级。

偏向锁

HotSpot的作者经过研究发现&＃xff0c;大多数情况下&＃xff0c;锁不仅不存在多线程竞争&＃xff0c;而且总是由同一线程多次获得。偏向锁是为了在只有一个线程执行同步块时提高性能。

当一个线程访问同步块并获取锁时&＃xff0c;会在对象头和栈帧中的锁记录里存储锁偏向的线程ID&＃xff0c;以后该线程在进入和退出同步块时不需要进行CAS操作来加锁和解锁&＃xff0c;只需简单地测试一下对象头的Mark Word里是否存储着指向当前线程的偏向锁。引入偏向锁是为了在无多线程竞争的情况下尽量减少不必要的轻量级锁执行路径&＃xff0c;因为轻量级锁的获取及释放依赖多次CAS原子指令&＃xff0c;而偏向锁只需要在置换ThreadID的时候依赖一次CAS原子指令&＃xff08;由于一旦出现多线程竞争的情况就必须撤销偏向锁&＃xff0c;所以偏向锁的撤销操作的性能损耗必须小于节省下来的CAS原子指令的性能消耗&＃xff09;。

偏向锁获取过程&＃xff1a;

• &＃xff08;1&＃xff09;访问Mark Word中偏向锁的标识是否设置成1&＃xff0c;锁标志位是否为01——确认为可偏向状态。
• &＃xff08;2&＃xff09;如果为可偏向状态&＃xff0c;则测试线程ID是否指向当前线程&＃xff0c;如果是&＃xff0c;进入步骤&＃xff08;5&＃xff09;&＃xff0c;否则进入步骤&＃xff08;3&＃xff09;。
• &＃xff08;3&＃xff09;如果线程ID并未指向当前线程&＃xff0c;则通过CAS操作竞争锁。如果竞争成功&＃xff0c;则将Mark Word中线程ID设置为当前线程ID&＃xff0c;然后执行&＃xff08;5&＃xff09;&＃xff1b;如果竞争失败&＃xff0c;执行&＃xff08;4&＃xff09;。
• &＃xff08;4&＃xff09;如果CAS获取偏向锁失败&＃xff0c;则表示有竞争&＃xff08;CAS获取偏向锁失败说明至少有过其他线程曾经获得过偏向锁&＃xff0c;因为线程不会主动去释放偏向锁&＃xff09;。当到达全局安全点&＃xff08;safepoint&＃xff09;时&＃xff0c;会首先暂停拥有偏向锁的线程&＃xff0c;然后检查持有偏向锁的线程是否活着&＃xff08;因为可能持有偏向锁的线程已经执行完毕&＃xff0c;但是该线程并不会主动去释放偏向锁&＃xff09;&＃xff0c;如果线程不处于活动状态&＃xff0c;则将对象头设置成无锁状态&＃xff08;标志位为“01”&＃xff09;&＃xff0c;然后重新偏向新的线程&＃xff1b;如果线程仍然活着&＃xff0c;撤销偏向锁后升级到轻量级锁状态&＃xff08;标志位为“00”&＃xff09;&＃xff0c;此时轻量级锁由原持有偏向锁的线程持有&＃xff0c;继续执行其同步代码&＃xff0c;而正在竞争的线程会进入自旋等待获得该轻量级锁。
• &＃xff08;5&＃xff09;执行同步代码。

偏向锁的释放过程&＃xff1a;

如上步骤&＃xff08;4&＃xff09;。偏向锁使用了一种等到竞争出现才释放偏向锁的机制&＃xff1a;偏向锁只有遇到其他线程尝试竞争偏向锁时&＃xff0c;持有偏向锁的线程才会释放锁&＃xff0c;线程不会主动去释放偏向锁。偏向锁的撤销&＃xff0c;需要等待全局安全点&＃xff08;在这个时间点上没有字节码正在执行&＃xff09;&＃xff0c;它会首先暂停拥有偏向锁的线程&＃xff0c;判断锁对象是否处于被锁定状态&＃xff0c;撤销偏向锁后恢复到未锁定&＃xff08;标志位为“01”&＃xff09;或轻量级锁&＃xff08;标志位为“00”&＃xff09;的状态。

关闭偏向锁&＃xff1a;

偏向锁在Java 6和Java 7里是默认启用的。由于偏向锁是为了在只有一个线程执行同步块时提高性能&＃xff0c;如果你确定应用程序里所有的锁通常情况下处于竞争状态&＃xff0c;可以通过JVM参数关闭偏向锁&＃xff1a;-XX:-UseBiasedLocking&＃61;false&＃xff0c;那么程序默认会进入轻量级锁状态。

轻量级锁

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

轻量级锁的加锁过程&＃xff1a;

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

• &＃xff08;2&＃xff09;拷贝对象头中的Mark Word复制到锁记录中。

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

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

• &＃xff08;5&＃xff09;如果这个更新操作失败了&＃xff0c;虚拟机首先会检查对象的Mark Word是否指向当前线程的栈帧&＃xff0c;如果是就说明当前线程已经拥有了这个对象的锁&＃xff0c;那就可以直接进入同步块继续执行。否则说明多个线程竞争锁&＃xff0c;若当前只有一个等待线程&＃xff0c;则可通过自旋稍微等待一下&＃xff0c;可能另一个线程很快就会释放锁。 但是当自旋超过一定的次数&＃xff0c;或者一个线程在持有锁&＃xff0c;一个在自旋&＃xff0c;又有第三个来访时&＃xff0c;轻量级锁膨胀为重量级锁&＃xff0c;重量级锁使除了拥有锁的线程以外的线程都阻塞&＃xff0c;防止CPU空转&＃xff0c;锁标志的状态值变为“10”&＃xff0c;Mark Word中存储的就是指向重量级锁&＃xff08;互斥量&＃xff09;的指针&＃xff0c;后面等待锁的线程也要进入阻塞状态。

轻量级锁的解锁过程&＃xff1a;

• &＃xff08;1&＃xff09;通过CAS操作尝试把线程中复制的Displaced Mark Word对象替换当前的Mark Word。
• &＃xff08;2&＃xff09;如果替换成功&＃xff0c;整个同步过程就完成了。
• &＃xff08;3&＃xff09;如果替换失败&＃xff0c;说明有其他线程尝试过获取该锁&＃xff08;此时锁已膨胀&＃xff09;&＃xff0c;那就要在释放锁的同时&＃xff0c;唤醒被挂起的线程。

重量级锁

如上轻量级锁的加锁过程步骤&＃xff08;5&＃xff09;&＃xff0c;轻量级锁所适应的场景是线程近乎交替执行同步块的情况&＃xff0c;如果存在同一时间访问同一锁的情况&＃xff0c;就会导致轻量级锁膨胀为重量级锁。Mark Word的锁标记位更新为10&＃xff0c;Mark Word指向互斥量&＃xff08;重量级锁&＃xff09;

Synchronized的重量级锁是通过对象内部的一个叫做监视器锁&＃xff08;monitor&＃xff09;来实现的&＃xff0c;监视器锁本质又是依赖于底层的操作系统的Mutex Lock&＃xff08;互斥锁&＃xff09;来实现的。而操作系统实现线程之间的切换需要从用户态转换到核心态&＃xff0c;这个成本非常高&＃xff0c;状态之间的转换需要相对比较长的时间&＃xff0c;这就是为什么Synchronized效率低的原因。

&＃xff08;具体见前面的mutex lock&＃xff09;

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

偏向所锁&＃xff0c;轻量级锁都是乐观锁&＃xff0c;重量级锁是悲观锁。

• 一个对象刚开始实例化的时候&＃xff0c;没有任何线程来访问它的时候。它是可偏向的&＃xff0c;意味着&＃xff0c;它现在认为只可能有一个线程来访问它&＃xff0c;所以当第一个线程来访问它的时候&＃xff0c;它会偏向这个线程&＃xff0c;此时&＃xff0c;对象持有偏向锁。偏向第一个线程&＃xff0c;这个线程在修改对象头成为偏向锁的时候使用CAS操作&＃xff0c;并将对象头中的ThreadID改成自己的ID&＃xff0c;之后再次访问这个对象时&＃xff0c;只需要对比ID&＃xff0c;不需要再使用CAS在进行操作。
• 一旦有第二个线程访问这个对象&＃xff0c;因为偏向锁不会主动释放&＃xff0c;所以第二个线程可以看到对象时偏向状态&＃xff0c;这时表明在这个对象上已经存在竞争了。检查原来持有该对象锁的线程是否依然存活&＃xff0c;如果挂了&＃xff0c;则可以将对象变为无锁状态&＃xff0c;然后重新偏向新的线程。如果原来的线程依然存活&＃xff0c;则马上执行那个线程的操作栈&＃xff0c;检查该对象的使用情况&＃xff0c;如果仍然需要持有偏向锁&＃xff0c;则偏向锁升级为轻量级锁&＃xff0c;&＃xff08;偏向锁就是这个时候升级为轻量级锁的&＃xff09;&＃xff0c;此时轻量级锁由原持有偏向锁的线程持有&＃xff0c;继续执行其同步代码&＃xff0c;而正在竞争的线程会进入自旋等待获得该轻量级锁&＃xff1b;如果不存在使用了&＃xff0c;则可以将对象回复成无锁状态&＃xff0c;然后重新偏向。
• 轻量级锁认为竞争存在&＃xff0c;但是竞争的程度很轻&＃xff0c;一般两个线程对于同一个锁的操作都会错开&＃xff0c;或者说稍微等待一下&＃xff08;自旋&＃xff09;&＃xff0c;另一个线程就会释放锁。 但是当自旋超过一定的次数&＃xff0c;或者一个线程在持有锁&＃xff0c;一个在自旋&＃xff0c;又有第三个来访时&＃xff0c;轻量级锁膨胀为重量级锁&＃xff0c;重量级锁使除了拥有锁的线程以外的线程都阻塞&＃xff0c;防止CPU空转。

其他锁优化

锁消除

锁消除即删除不必要的加锁操作。虚拟机即时编辑器在运行时&＃xff0c;对一些“代码上要求同步&＃xff0c;但是被检测到不可能存在共享数据竞争”的锁进行消除。

根据代码逃逸技术&＃xff0c;如果判断到一段代码中&＃xff0c;堆上的数据不会逃逸出当前线程&＃xff0c;那么可以认为这段代码是线程安全的&＃xff0c;不必要加锁。

看下面这段程序&＃xff1a;

public class SynchronizedTest {public static void main(String[] args) {SynchronizedTest test &＃61; new SynchronizedTest();for (int i &＃61; 0; i <100000000; i&＃43;&＃43;) {test.append("abc", "def");}}public void append(String str1, String str2) {StringBuffer sb &＃61; new StringBuffer();sb.append(str1).append(str2);}
}


虽然StringBuffer的append是一个同步方法&＃xff0c;但是这段程序中的StringBuffer属于一个局部变量&＃xff0c;并且不会从该方法中逃逸出去&＃xff08;即StringBuffer sb的引用没有传递到该方法外&＃xff0c;不可能被其他线程拿到该引用&＃xff09;&＃xff0c;所以其实这过程是线程安全的&＃xff0c;可以将锁消除。

锁粗化

如果一系列的连续操作都对同一个对象反复加锁和解锁&＃xff0c;甚至加锁操作是出现在循环体中的&＃xff0c;那即使没有出现线程竞争&＃xff0c;频繁地进行互斥同步操作也会导致不必要的性能损耗。

如果虚拟机检测到有一串零碎的操作都是对同一对象的加锁&＃xff0c;将会把加锁同步的范围扩展&＃xff08;粗化&＃xff09;到整个操作序列的外部。

举个例子&＃xff1a;

public class StringBufferTest {StringBuffer stringBuffer &＃61; new StringBuffer();public void append(){stringBuffer.append("a");stringBuffer.append("b");stringBuffer.append("c");}
}


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

自旋锁与自适应自旋锁

• 引入自旋锁的原因&＃xff1a; 互斥同步对性能最大的影响是阻塞的实现&＃xff0c;因为挂起线程和恢复线程的操作都需要转入内核态中完成&＃xff0c;这些操作给系统的并发性能带来很大的压力。同时虚拟机的开发团队也注意到在许多应用上面&＃xff0c;共享数据的锁定状态只会持续很短一段时间&＃xff0c;为了这一段很短的时间频繁地阻塞和唤醒线程是非常不值得的。
• 自旋锁&＃xff1a; 让该线程执行一段无意义的忙循环&＃xff08;自旋&＃xff09;等待一段时间&＃xff0c;不会被立即挂起&＃xff08;自旋不放弃处理器额执行时间&＃xff09;&＃xff0c;看持有锁的线程是否会很快释放锁。自旋锁在JDK 1.4.2中引入&＃xff0c;默认关闭&＃xff0c;但是可以使用-XX:&＃43;UseSpinning开开启&＃xff1b;在JDK1.6中默认开启。
• 自旋锁的缺点&＃xff1a; 自旋等待不能替代阻塞&＃xff0c;虽然它可以避免线程切换带来的开销&＃xff0c;但是它占用了处理器的时间。如果持有锁的线程很快就释放了锁&＃xff0c;那么自旋的效率就非常好&＃xff1b;反之&＃xff0c;自旋的线程就会白白消耗掉处理器的资源&＃xff0c;它不会做任何有意义的工作&＃xff0c;这样反而会带来性能上的浪费。所以说&＃xff0c;自旋等待的时间&＃xff08;自旋的次数&＃xff09;必须要有一个限度&＃xff0c;例如让其循环10次&＃xff0c;如果自旋超过了定义的时间仍然没有获取到锁&＃xff0c;则应该被挂起&＃xff08;进入阻塞状态&＃xff09;。通过参数-XX:PreBlockSpin可以调整自旋次数&＃xff0c;默认的自旋次数为10。
• 自适应的自旋锁&＃xff1a; JDK1.6引入自适应的自旋锁&＃xff0c;自适应就意味着自旋的次数不再是固定的&＃xff0c;它是由前一次在同一个锁上的自旋时间及锁的拥有者的状态来决定&＃xff1a;如果在同一个锁的对象上&＃xff0c;自旋等待刚刚成功获得过锁&＃xff0c;并且持有锁的线程正在运行中&＃xff0c;那么虚拟机就会认为这次自旋也很有可能再次成功&＃xff0c;进而它将允许自旋等待持续相对更长的时间。如果对于某个锁&＃xff0c;自旋很少成功获得过&＃xff0c;那在以后要获取这个锁时将可能省略掉自旋过程&＃xff0c;以避免浪费处理器资源。简单来说&＃xff0c;就是线程如果自旋成功了&＃xff0c;则下次自旋的次数会更多&＃xff0c;如果自旋失败了&＃xff0c;则自旋的次数就会减少。
• 自旋锁使用场景&＃xff1a; 从轻量级锁获取的流程中我们知道&＃xff0c;当线程在获取轻量级锁的过程中执行CAS操作失败时&＃xff0c;是要通过自旋来获取重量级锁的。&＃xff08;见前面“轻量级锁”&＃xff09;

总结

• synchronized特点&＃xff1a; 保证内存可见性、操作原子性
• synchronized影响性能的原因&＃xff1a;
  • 1、加锁解锁操作需要额外操作&＃xff1b;
  • 2、互斥同步对性能最大的影响是阻塞的实现&＃xff0c;因为阻塞涉及到的挂起线程和恢复线程的操作都需要转入内核态中完成&＃xff08;用户态与内核态的切换的性能代价是比较大的&＃xff09;
• synchronized锁&＃xff1a; 对象头中的Mark Word根据锁标志位的不同而被复用
  • 偏向锁&＃xff1a;在只有一个线程执行同步块时提高性能。Mark Word存储锁偏向的线程ID&＃xff0c;以后该线程在进入和退出同步块时不需要进行CAS操作来加锁和解锁&＃xff0c;只需简单比较ThreadID。特点&＃xff1a;只有等到线程竞争出现才释放偏向锁&＃xff0c;持有偏向锁的线程不会主动释放偏向锁。之后的线程竞争偏向锁&＃xff0c;会先检查持有偏向锁的线程是否存活&＃xff0c;如果不存货&＃xff0c;则对象变为无锁状态&＃xff0c;重新偏向&＃xff1b;如果仍存活&＃xff0c;则偏向锁升级为轻量级锁&＃xff0c;此时轻量级锁由原持有偏向锁的线程持有&＃xff0c;继续执行其同步代码&＃xff0c;而正在竞争的线程会进入自旋等待获得该轻量级锁
  • 轻量级锁&＃xff1a;在当前线程的栈帧中建立一个名为锁记录&＃xff08;Lock Record&＃xff09;的空间&＃xff0c;尝试拷贝锁对象目前的Mark Word到栈帧的Lock Record&＃xff0c;若拷贝成功&＃xff1a;虚拟机将使用CAS操作尝试将对象的Mark Word更新为指向Lock Record的指针&＃xff0c;并将Lock record里的owner指针指向对象的Mark Word。若拷贝失败&＃xff1a;若当前只有一个等待线程&＃xff0c;则可通过自旋稍微等待一下&＃xff0c;可能持有轻量级锁的线程很快就会释放锁。 但是当自旋超过一定的次数&＃xff0c;或者一个线程在持有锁&＃xff0c;一个在自旋&＃xff0c;又有第三个来访时&＃xff0c;轻量级锁膨胀为重量级锁
  • 重量级锁&＃xff1a;指向互斥量&＃xff08;mutex&＃xff09;&＃xff0c;底层通过操作系统的mutex lock实现。等待锁的线程会被阻塞&＃xff0c;由于Linux下Java线程与操作系统内核态线程一一映射&＃xff0c;所以涉及到用户态和内核态的切换、操作系统内核态中的线程的阻塞和恢复。

参考来源

《深入理解Java虚拟机》
《Java并发编程的艺术》
http://www.cnblogs.com/paddix/p/5367116.html
http://www.cnblogs.com/paddix/p/5405678.html
http://blog.csdn.net/choukekai/article/details/63688332
https://www.zhihu.com/question/57774162/answer/154298044
http://www.jianshu.com/p/8d7d2d081adf