Java偏向锁升级：从轻量级锁到重量级锁的JVM状态转换过程
大家好，今天我们来深入探讨Java并发编程中一个非常重要的概念：偏向锁的升级过程。理解这个过程对于优化多线程程序的性能至关重要。我们将从偏向锁的基本原理出发，逐步分析它如何升级到轻量级锁，最终演变为重量级锁。整个过程涉及大量的JVM内部机制，我会尽可能用清晰易懂的方式进行讲解，并辅以代码示例。
1. 偏向锁的诞生与目的
在并发编程中，锁是保证数据一致性的关键机制。然而，在某些情况下，线程对锁的竞争并不激烈，甚至可能长时间只有单个线程访问同步代码块。为了优化这种场景，JVM引入了偏向锁。
偏向锁的核心思想是：如果一个锁总是被同一个线程持有，那么就消除这个线程获取锁的开销。 这意味着当线程第一次获取锁时，JVM会将锁的状态设置为“偏向”该线程，并在锁对象的对象头中记录该线程的ID。后续该线程再次访问同步代码块时，无需进行任何同步操作，直接进入即可。
我们可以用一个简单的例子来说明：
public class BiasedLockExample {
private static Object lock = new Object();
public static void main(String[] args) {
synchronized (lock) {
System.out.println("First time acquiring the lock by thread: " + Thread.currentThread().getName());
}
synchronized (lock) {
System.out.println("Second time acquiring the lock by thread: " + Thread.currentThread().getName());
}
}
}在这个例子中，lock对象只会被主线程访问。理想情况下，第一次进入synchronized块时，lock对象会被偏向主线程，后续再次进入时，主线程可以直接进入，避免了锁的竞争开销。
2. 偏向锁的初始状态与设置
当JVM启动时，并不是所有对象都会立即启用偏向锁。默认情况下，有一个延迟启用时间，可以通过-XX:BiasedLockingStartupDelay参数来设置。这是因为大多数应用在启动初期线程竞争比较激烈，立即启用偏向锁可能会导致频繁的锁撤销，反而降低性能。
那么，一个新的对象是如何被设置为偏向锁的呢？
- 对象头的mark word： 每个Java对象都有一个对象头，其中包含
mark word。mark word记录了对象的哈希码、GC分代年龄以及锁状态等信息。 - 匿名偏向： 当一个对象被创建并且还没有线程尝试获取锁时，其
mark word处于“匿名偏向”状态，这意味着该对象可以被偏向任何线程。 - 偏向线程ID： 当第一个线程尝试获取锁时，JVM会将
mark word中的偏向标志位设置为1，并将线程ID写入mark word中的相应位置。此时，该对象就偏向了这个线程。
我们可以用一个表格来总结mark word在不同锁状态下的结构：
| 锁状态 | 标志位 | 状态位 | 对象哈希码 | 分代年龄 | 偏向线程ID/锁指针 |
|---|---|---|---|---|---|
| 无锁 | 0 | 01 | 对象哈希码 | 分代年龄 | 空 |
| 偏向锁 | 1 | 01 | 对象哈希码 | 分代年龄 | 偏向线程ID |
| 轻量级锁 | 0 | 00 | 对象哈希码 | 分代年龄 | 锁指针 |
| 重量级锁 | 1 | 00 | 对象哈希码 | 分代年龄 | 锁指针 |
| GC标记 | 1 | 11 | 对象哈希码 | 分代年龄 | 空 |
3. 偏向锁的撤销与升级
偏向锁的优势在于减少了锁的获取开销，但它也存在局限性：如果另一个线程尝试获取已经被偏向的锁，偏向锁就会被撤销。 撤销的过程比较复杂，涉及以下几种情况：
- 线程竞争： 当另一个线程尝试获取已经被偏向的锁时，JVM会检查当前持有偏向锁的线程是否仍然存活。
- 线程暂停： 如果持有偏向锁的线程仍然存活，JVM会尝试暂停该线程，并检查该线程是否正在执行同步代码块。
- 锁升级： 如果持有偏向锁的线程已经执行完同步代码块或者已经死亡，JVM会将锁升级为轻量级锁。
- 批量撤销： 如果同一个类的对象频繁发生偏向锁撤销，JVM可能会启用批量撤销机制，直接将该类的所有对象的偏向锁禁用。
4. 轻量级锁的获取与释放
当偏向锁被撤销后，锁会升级为轻量级锁。轻量级锁的实现基于CAS（Compare and Swap）操作。
- 线程栈帧： 每个线程都有自己的栈帧，用于存储局部变量、操作数栈等信息。
- 锁记录： 当线程尝试获取轻量级锁时，JVM会在线程的栈帧中创建一个锁记录（Lock Record），并将对象头的
mark word复制到锁记录中。 - CAS操作： 线程尝试使用CAS操作将对象头的
mark word替换为指向锁记录的指针。 - 成功获取： 如果CAS操作成功，则线程成功获取轻量级锁，可以进入同步代码块。
- 自旋等待： 如果CAS操作失败，说明有其他线程正在持有该锁。此时，线程会进行自旋等待，不断尝试CAS操作，直到获取锁或者自旋次数超过阈值。
以下代码展示了轻量级锁的获取和释放过程：
public class LightweightLockExample {
private static Object lock = new Object();
public static void main(String[] args) {
Runnable task = () -> {
synchronized (lock) {
System.out.println(Thread.currentThread().getName() + " acquired the lock.");
try {
Thread.sleep(100); // 模拟执行同步代码块
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " released the lock.");
}
};
Thread thread1 = new Thread(task, "Thread-1");
Thread thread2 = new Thread(task, "Thread-2");
thread1.start();
thread2.start();
}
}在这个例子中，Thread-1和Thread-2会竞争lock对象。如果lock对象最初处于偏向锁状态，当Thread-2尝试获取锁时，偏向锁会被撤销，升级为轻量级锁。两个线程会通过CAS操作竞争锁，失败的线程会进行自旋等待。
5. 轻量级锁的膨胀与重量级锁
轻量级锁通过自旋等待来避免线程阻塞，但如果多个线程长时间竞争同一个锁，自旋会消耗大量的CPU资源。当自旋次数超过一定阈值，或者有其他线程阻塞等待该锁时，轻量级锁会膨胀为重量级锁。
- 系统调用： 重量级锁依赖于操作系统的互斥量（Mutex）来实现线程同步。当线程尝试获取重量级锁时，如果锁已经被其他线程持有，该线程会被阻塞，进入等待队列。
- 上下文切换： 线程阻塞会导致上下文切换，这是非常耗时的操作。
- 锁指针： 对象头的
mark word会存储指向互斥量的指针。
重量级锁的获取和释放过程如下：
- 线程尝试获取锁，如果锁未被占用，则获取锁并执行同步代码块。
- 如果锁已经被其他线程占用，则线程进入等待队列，等待操作系统唤醒。
- 当持有锁的线程释放锁时，操作系统会从等待队列中选择一个线程唤醒，该线程重新尝试获取锁。
以下代码展示了重量级锁的使用：
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class HeavyweightLockExample {
private static Lock lock = new ReentrantLock();
public static void main(String[] args) {
Runnable task = () -> {
lock.lock(); // 获取锁
try {
System.out.println(Thread.currentThread().getName() + " acquired the lock.");
Thread.sleep(100); // 模拟执行同步代码块
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
System.out.println(Thread.currentThread().getName() + " released the lock.");
lock.unlock(); // 释放锁
}
};
Thread thread1 = new Thread(task, "Thread-1");
Thread thread2 = new Thread(task, "Thread-2");
thread1.start();
thread2.start();
}
}在这个例子中，我们使用了ReentrantLock来实现重量级锁。ReentrantLock底层依赖于AQS（AbstractQueuedSynchronizer），AQS利用CAS和CLH队列来实现线程同步。
6. JVM参数与锁优化
JVM提供了一些参数来控制锁的行为，可以根据具体的应用场景进行调整：
| 参数 | 描述 | 默认值 |
|---|---|---|
-XX:+UseBiasedLocking |
启用偏向锁 | 启用 (JDK 15及更高版本默认禁用) |
-XX:-UseBiasedLocking |
禁用偏向锁 | |
-XX:BiasedLockingStartupDelay |
偏向锁启动延迟时间（秒） | 4 秒 |
-XX:PreBlockSpin |
自旋等待的次数 | 10 |
-XX:+UseAdaptiveSpinning |
启用自适应自旋，JVM会根据历史数据动态调整自旋次数 | 启用 |
7. 锁升级的流程总结
我们可以用一个流程图来总结锁升级的过程：
graph LR
A[对象创建 (无锁状态)] --> B{第一个线程尝试获取锁};
B -- 是 --> C[偏向锁];
B -- 否 --> A;
C --> D{其他线程尝试获取锁};
D -- 是 --> E{检查持有偏向锁的线程状态};
E -- 存活且正在执行同步代码块 --> F[撤销偏向锁，升级为轻量级锁];
E -- 不存活或未执行同步代码块 --> F;
D -- 否 --> C;
F --> G{CAS操作竞争锁};
G -- 成功 --> H[获取轻量级锁];
G -- 失败 --> I{自旋等待};
I -- 达到自旋阈值或有其他线程阻塞 --> J[升级为重量级锁];
I -- 未达到自旋阈值 --> G;
J --> K[线程阻塞，等待操作系统唤醒];
H --> L[执行同步代码块];
L --> M[释放锁];
M --> N[锁状态改变];
K --> N;锁升级的流程总结：
- 初始： 对象创建时处于无锁状态。
- 偏向： 第一个线程获取锁时，升级为偏向锁。
- 轻量级： 其他线程竞争锁时，偏向锁撤销，升级为轻量级锁。
- 重量级： 轻量级锁自旋失败或有其他线程阻塞时，升级为重量级锁。
8. 如何避免不必要的锁升级
了解锁升级的机制后，我们可以采取一些措施来避免不必要的锁升级，从而提高程序的性能：
- 减少锁的持有时间： 尽可能缩短同步代码块的执行时间，减少线程竞争的可能性。
- 避免多个线程竞争同一个锁： 可以使用线程本地变量（ThreadLocal）来避免多个线程访问共享变量。
- 使用更细粒度的锁： 将一个大的锁拆分成多个小的锁，可以减少线程竞争的范围。
- 使用无锁数据结构： 在某些情况下，可以使用无锁数据结构（例如ConcurrentHashMap、AtomicInteger）来避免锁的使用。
9. 锁升级过程中的性能考量
锁升级过程本身也会带来一定的性能开销。例如，偏向锁的撤销需要暂停线程，轻量级锁的自旋会消耗CPU资源，重量级锁的上下文切换开销很大。因此，在设计并发程序时，需要综合考虑锁的使用场景，选择合适的锁策略，并尽量避免频繁的锁升级。
10. 不同锁之间的适用场景
- 偏向锁： 适用于只有一个线程访问同步代码块的场景。
- 轻量级锁： 适用于线程竞争不激烈，且持有锁的时间较短的场景。
- 重量级锁： 适用于线程竞争激烈，且持有锁的时间较长的场景。
一些需要注意的点：
- 锁粗化： JVM可能会进行锁粗化优化，将多个相邻的同步代码块合并成一个大的同步代码块，从而减少锁的获取和释放次数。
- 锁消除： JVM可能会进行锁消除优化，如果发现某个锁只被单个线程访问，则会消除该锁。
- 监控工具： 可以使用JConsole、VisualVM等工具来监控锁的使用情况，帮助我们分析和优化程序的性能。
今天我们详细讨论了Java中偏向锁的升级过程，从偏向锁到轻量级锁再到重量级锁，每一步都涉及复杂的JVM内部机制。理解这些机制有助于我们编写更高效的并发程序。希望今天的讲解对大家有所帮助。
锁升级的本质：
锁升级是为了在不同的并发场景下找到性能的最佳平衡点。偏向锁适用于单线程场景，轻量级锁适用于轻度竞争场景，重量级锁适用于高度竞争场景。
优化并发程序：
理解锁升级机制有助于我们选择合适的锁策略，减少不必要的锁竞争，最终优化并发程序的性能。