在 JDK 1.8 中，synchronized 关键字的性能得到了显著提升，这主要得益于 JVM 对锁机制进行了一系列优化：锁的分级及其优化路径（大体可以按照下面的路径进行升级：偏向锁 — 轻量级锁 — 重量级锁，锁只能升级，不能降级，所以一旦升级为重量级锁，就只能依靠操作系统进行调度）。
要想了解锁升级的过程，需要先看一下对象在内存里的结构。
在 Java 中，对象的内存布局中包含了 MarkWord、Class Pointer、Instance Data 和 Padding 等部分。而锁的升级过程主要与对象头的 MarkWord 有关。
要知道MarkWord 是对象头中用于存储对象的运行时信息的。在 64 位 JVM 中，MarkWord 的长度为 64 位。在 32 位 JVM 中，MarkWord 的长度为 32 位（如上图）。
偏向锁（Biased Locking）
单线程高效使用锁：在只有一个线程使用锁的情况下，偏向锁效率最高。
获取锁：第一个线程访问同步块时，会检查对象头 Mark Word 的标志位 Tag 是否为 01。如果是，线程将自己的线程 ID 写入 Mark Word，锁进入偏向锁状态。
撤销偏向锁：当其他线程尝试获取锁时，如果 Mark Word 中的线程 ID 不匹配，偏向锁会被撤销，升级为轻量级锁。
适合单线程场景，高效。
轻量级锁
自旋锁获取：参与竞争的线程会在自己的线程栈中生成一个 LockRecord (LR)，通过 CAS（自旋）的方式，将锁对象头中的 Mark Word 设置为指向自己的 LR 的指针。设置成功的线程获得锁。
自旋失败：如果自旋多次失败，锁会升级为重量级锁。
适合短期竞争，自旋获取锁。
重量级锁
系统调度：重量级锁会导致线程挂起，进入操作系统内核态，等待操作系统调度，然后再映射回用户态。系统调用的开销很高，锁的膨胀到重量级锁就意味着性能下降。
激烈竞争：如果共享变量竞争激烈，锁会迅速膨胀为重量级锁。如果并发竞争严重，可以使用 -XX:-UseBiasedLocking 禁用偏向锁，可能会有一些性能提升。
适合长期竞争，但性能开销大。
3. 锁升级一览
（二）concurrent 包里面的 Lock
synchronized 是 Java 提供的最基本的同步机制，通过简单易用的语法确保线程安全。然而，随着并发需求的复杂化，Java 的并发包 (java.util.concurrent) 提供了更多高级和高效的并发工具，如 ReentrantLock、ReadWriteLock、Atomic 类等，来应对更复杂的并发场景。在实际开发中，应根据具体情况选择合适的同步机制。现在我们聚焦在Lock进行分析。
1. 锁机制基于线程而不是基于调用（可重入锁）
“这种锁机制基于线程而不是基于调用” 的意思是说，当一个线程持有锁时，它可以在同一个线程的不同调用链中多次获取同一把锁，而不会被阻塞或引发死锁。这是因为锁是跟线程关联的，而不是跟调用栈关联的。
假设有一个对象 example，它有三个同步方法 a、b 和 c，每个方法都被 synchronized 关键字修饰：
package org.zyf.javabasic.thread.lock.opti;
/**
* @program: zyfboot-javabasic
* @description: 锁机制基于线程而不是基于调用
* @author: zhangyanfeng
* @create: 2024-06-07 19:04
**/
public class LockExample {
public synchronized void a() {
System.out.println("In method a");
b(); // 调用 b 方法
}
public synchronized void b() {
System.out.println("In method b");
c(); // 调用 c 方法
}
public synchronized void c() {
System.out.println("In method c");
}
public static void main(String[] args) {
LockExample example = new LockExample();
example.a();
}
}
在 main 方法中，我们调用了 example.a()。在 a 方法内部，又调用了 b 方法，而 b 方法内部又调用了 c 方法。这种调用关系如下：
example.a()
-> example.b()
-> example.c()
当线程调用 example.a() 时，由于 a 方法是同步方法，线程必须先获得对象 example 的锁。在 a 方法内部，线程调用 example.b()。虽然 b 方法也是同步方法，但是由于当前线程已经持有了 example 对象的锁，所以它可以继续执行，不需要再次获取锁。类似地，在 b 方法内部，线程调用 example.c() 时，也不需要再次获取锁。
这个过程中锁是跟线程关联的，而不是跟每次调用关联的。一个线程持有锁之后，可以在它的调用栈中多次获取同一把锁，而不需要重新获取锁，也不会被阻塞。
如果 Java 的锁机制不是基于线程的，而是基于每次调用的，那么在上面的示例中，线程在调用 b 方法时会尝试再次获取 example 对象的锁，但是由于它已经持有这个锁，这将导致死锁。因此，基于线程的锁机制（即可重入锁）避免了这种情况，使得一个线程在持有锁时，可以多次获取同一把锁。Java 的 ReentrantLock 类也支持可重入性，将以上synchronized替换成其效果也是一样的。
像上面这样，在并发编程中，可重入锁（Reentrant Lock）指的是一个线程可以多次获得同一把锁。可重入锁的作用在于避免线程死锁，当一个线程已经持有了一个锁，再次请求该锁时可以直接获取，而无需再次等待。这种锁机制基于线程而不是基于调用。
