深入剖析synchronized、ReentrantLock、StampedLock、读写锁等核心锁机制,结合真实面试题与源码级分析,覆盖锁升级、锁消除、公平性、性能对比、线程安全等高频考点,助您系统掌握Java并发编程关键技能。
立即查阅在Java并发编程中,锁是保障线程安全的核心机制。从JDK 1.0的内置锁(synchronized),到JDK 5引入的java.util.concurrent包(JUC)中的显式锁体系,锁机制经历了多次重大演进。理解锁的设计哲学、适用场景与性能差异,是应对中高级Java岗位面试的必修课。
主流锁分类如下:
下表对比主流锁的关键特性:
| 锁类型 | 是否可重入 | 是否支持公平性 | 是否支持条件队列 | 是否支持中断 | 是否支持超时 | 典型使用场景 |
|---|---|---|---|---|---|---|
| synchronized | ✅ | ❌(非公平) | ✅(通过wait/notify) | ❌ | ❌ | 简单同步、方法级/代码块级保护 |
| ReentrantLock | ✅ | ✅(构造器指定) | ✅(Condition接口) | ✅(lockInterruptibly) | ✅(tryLock) | 复杂同步控制、需要中断/超时/公平性保障 |
| ReentrantReadWriteLock | ✅(读/写锁各自重入) | ✅ | ✅(读锁/写锁各配Condition) | ✅ | ✅ | 读多写少场景(如缓存更新、配置管理) |
| StampedLock | ✅(写锁重入) | ❌(不支持公平性) | ❌ | ✅(writeLockInterruptibly) | ✅(tryConvertWriteLock) | 高性能读多写少场景(如坐标计算、事件日志) |
需要特别注意:ReentrantReadWriteLock的读锁不支持Condition,写锁支持;而StampedLock不支持Condition,但提供更轻量级的乐观读(optimistic read),在无竞争时性能接近无锁。
早期synchronized基于操作系统互斥量(mutex)实现,开销较大;JDK 6起引入偏向锁→轻量级锁→重量级锁的升级机制,通过对象头Mark Word的标志位动态调整锁状态,大幅提升低竞争场景性能。
对象头结构(64位JVM):
锁标志位含义(2位):
锁升级流程:
无锁 → 偏向锁(单线程重复获取) → 轻量级锁(自旋竞争) → 重量级锁(多线程竞争激烈)
⚠️ 注意:锁只能升级,不能降级!偏向锁可被撤销(bulk rebias / revoke),但撤销后不再恢复偏向状态。
示例代码:
public class Account {
private int balance;
// 实例方法锁:每个实例独立锁
public synchronized void deposit(int amount) {
balance += amount;
}
// 静态方法锁:全局唯一锁
public static synchronized void resetCounter() {
counter = 0;
}
// 代码块锁:精确控制锁粒度
public void transfer(Account target, int amount) {
synchronized (this) { // 锁当前对象
if (balance >= amount) {
balance -= amount;
target.deposit(amount);
}
}
}
}
synchronized不仅保证原子性,还确保内存可见性:
相当于隐式使用了volatile的内存屏障语义,但范围仅限同步块内变量。
反例:
// 错误示例:每次拼接生成新String对象,锁对象不一致!
private String lock = "";
public void badExample() {
synchronized (lock += "x") { // 每次锁不同对象!
// 临界区
}
}
| 维度 | synchronized | volatile |
|---|---|---|
| 原子性 | ✅ 保证复合操作原子性 | ❌ 仅保证单次读/写原子性 |
| 可见性 | ✅ | ✅ |
| 有序性 | ✅(happens-before) | ✅(禁止指令重排) |
| 阻塞 | 是(重量级锁) | 否(仅内存屏障) |
| 适用场景 | 多线程写、复合操作 | 单变量状态标志、状态发布 |
Condition使用示例:
class BoundedBuffer {
final Lock lock = new ReentrantLock();
final Condition notFull = lock.newCondition();
final Condition notEmpty = lock.newCondition();
final Object[] items = new Object[100];
int putptr, takeptr, count;
public void put(Object x) throws InterruptedException {
lock.lock();
try {
while (count == items.length)
notFull.await();
items[putptr] = x;
if (++putptr == items.length) putptr = 0;
++count;
notEmpty.signal();
} finally {
lock.unlock();
}
}
public Object take() throws InterruptedException {
lock.lock();
try {
while (count == 0)
notEmpty.await();
Object x = items[takeptr];
if (++takeptr == items.length) takeptr = 0;
--count;
notFull.signal();
return x;
} finally {
lock.unlock();
}
}
}
非公平锁(默认):
公平锁:
源码关键差异:
// 非公平锁tryAcquire
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
// 公平锁tryAcquire(增加hasQueuedPredecessors检查)
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (!hasQueuedPredecessors() && // 关键差异:检查前驱节点
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
反例(导致死锁):
// ❌ 错误:异常时未释放锁
lock.lock();
try {
// 可能抛异常的操作
riskyOperation();
// 若异常发生,以下unlock不执行!
lock.unlock();
}
✅ 正确写法:
lock.lock();
try {
riskyOperation();
} finally {
lock.unlock(); // 总在finally释放
}
核心API:
示例:乐观读用于缓存校验
class Point {
private double x, y;
final StampedLock sl = new StampedLock();
// 乐观读:无竞争时高效
double distanceFromOrigin() {
long stamp = sl.tryOptimisticRead();
double currentX = x, currentY = y;
if (!sl.validate(stamp)) { // 检查时间戳是否失效
stamp = sl.readLock(); // 升级为悲观读锁
try {
currentX = x;
currentY = y;
} finally {
sl.unlockRead(stamp);
}
}
return Math.sqrt(currentX * currentX + currentY * currentY);
}
// 写操作
void move(double deltaX, double deltaY) {
long stamp = sl.writeLock();
try {
x += deltaX;
y += deltaY;
} finally {
sl.unlockWrite(stamp);
}
}
}
支持三种转换(可能失败):
失败时返回0,需重新获取锁。
性能对比(读多写少场景):
| 指标 | StampedLock | ReentrantReadWriteLock |
|---|---|---|
| 读吞吐量 | 极高(乐观读接近无锁) | 中等 |
| 写吞吐量 | 中等 | 高 |
| 延迟波动 | 高(乐观读失败需重试) | 低 |
| 适用场景 | 高吞吐、低延迟容忍场景 | 强一致性、稳定延迟场景 |
典型应用场景:缓存更新
class Cache {
final Map cache = new HashMap<>();
final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
V get(K key) {
V value = cache.get(key);
if (value == null) {
rwLock.writeLock().lock(); // 双重检查锁定(DCL)
try {
value = cache.get(key);
if (value == null) {
value = loadFromDB(key); // 模拟数据库加载
cache.put(key, value);
}
} finally {
rwLock.writeLock().unlock();
}
}
return value;
}
void put(K key, V value) {
rwLock.writeLock().lock();
try {
cache.put(key, value);
} finally {
rwLock.writeLock().unlock();
}
}
}
不支持读锁升级为写锁!否则导致死锁:
// ❌ 错误:读锁持有时尝试获取写锁 → 死锁
rwLock.readLock().lock();
try {
// 尝试升级为写锁
long stamp = rwLock.writeLock().tryLock(); // 永远等待!
...
} finally {
rwLock.readLock().unlock();
}
支持写锁降级为读锁(JDK保证):
// ✅ 正确:写锁持有时获取读锁,释放写锁 → 保持读锁
rwLock.writeLock().lock();
try {
// 修改数据
cache.put(key, newValue);
// 获取读锁
long readStamp = rwLock.readLock().tryLock();
rwLock.writeLock().unlock(); // 释放写锁
// 继续使用读锁
...
rwLock.readLock().unlock();
}
JIT编译器通过逃逸分析(Escape Analysis)判断对象是否逃逸出线程:
示例:JDK 8中StringBuffer.append()被优化为无锁
// 编译后等效于:直接操作字符数组,无同步
StringBuffer sb = new StringBuffer();
sb.append("a").append("b").append("c"); // 等效于 sb.append("abc")
JIT将多个连续加锁/解锁操作合并为一个大锁:
// 原始代码
for (int i = 0; i < 1000; i++) {
synchronized(lock) {
// 简单操作
}
}
// 优化后等效于
synchronized(lock) {
for (int i = 0; i < 1000; i++) {
// 简单操作
}
}
当多个线程竞争偏向锁时,JVM执行批量撤销:
可通过参数禁用偏向锁(JDK 15+默认禁用):
-XX:-UseBiasedLocking
轻量级锁失败后,线程自旋等待(避免线程挂起开销):
参数调整:
-XX:PreBlockSpin=10 // 自旋次数
-XX:UseAdaptiveSpin=true // 启用自适应
将大锁拆分为多个小锁,降低竞争:
经典案例:ConcurrentHashMap(JDK 7)使用Segment数组:
// JDK 7 Segment结构
final Segment[] segments;
static final class Segment extends ReentrantLock { ... }
JDK 8改为CAS+synchronized组合,进一步降低锁粒度。
错误:使用可变对象作为锁
// ❌ 错误:this在继承中可能被覆盖
class Parent {
synchronized void method() { ... }
}
class Child extends Parent {
// 未重写,但锁对象变为this(子类实例)
}
正确:使用final私有锁对象
class SafeClass {
private final Object lock = new Object();
void safeMethod() {
synchronized(lock) { ... }
}
}
死锁四要素(需同时满足):
预防策略:
示例:银行转账死锁场景
// ❌ 错误:可能死锁
void transfer(Account from, Account to, int amount) {
synchronized(from) {
synchronized(to) { // 若A→B与B→A同时发生 → 死锁
from.balance -= amount;
to.balance += amount;
}
}
}
// ✅ 正确:按账号哈希排序加锁
void transfer(Account from, Account to, int amount) {
Account first = from.id < to.id ? from : to;
Account second = from.id < to.id ? to : from;
synchronized(first) {
synchronized(second) {
from.balance -= amount;
to.balance += amount;
}
}
}
在锁等待中响应中断:
// ✅ 正确:中断时清理资源
try {
lock.lockInterruptibly();
// 临界区
} catch (InterruptedException e) {
// 恢复中断状态
Thread.currentThread().interrupt();
// 清理逻辑
return;
} finally {
if (lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
答:Java锁分为内置锁(synchronized)、显式锁(Lock实现类)和特殊锁(StampedLock)。synchronized适用于简单同步场景;ReentrantLock适用于需要中断、超时、公平性等高级功能的场景;StampedLock适用于读多写少且对延迟敏感的高性能场景。实际开发中应优先使用synchronized,仅在需要其不支持的功能时才选择其他锁。
答:synchronized锁升级路径为:无锁 → 偏向锁(单线程重复获取) → 轻量级锁(自旋竞争) → 重量级锁(多线程竞争激烈)。锁只能升级不能降级,偏向锁可被撤销(bulk rebias/revoke),但撤销后不再恢复偏向状态。JDK 15起默认禁用偏向锁以简化GC。
答:通过AQS的state变量记录锁持有次数。获取锁时,若state为0则CAS设置为1;若当前线程已持有锁(getExclusiveOwnerThread() == current),则state累加。释放锁时,state递减至0才真正释放。
答:乐观读通过时间戳机制实现。获取锁时返回当前时间戳stamp;读取数据后调用validate(stamp)检查时间戳是否被写操作更新。若未更新,说明读期间无写入,数据有效;否则需升级为悲观读锁重新读取。该机制在无竞争时性能接近无锁,但可能因写操作频繁导致验证失败率高。
答:死锁预防策略包括:① 固定加锁顺序(如按对象哈希码排序);② 使用tryLock+超时回退;③ 锁分级(Lock Ordering);④ 减少锁持有时间;⑤ 使用并发容器(如ConcurrentHashMap)替代手动加锁。实践中应优先选择无锁方案(如原子变量),其次考虑使用高级并发工具类。
答:synchronized保证原子性、可见性、有序性,但可能阻塞;volatile仅保证可见性和有序性(禁止指令重排),不保证原子性。synchronized适用于复合操作(如i++),volatile适用于状态标志(如boolean flag)。两者可结合使用:volatile确保状态发布,synchronized确保操作原子性。
答:JDK 6引入偏向锁和轻量级锁机制。偏向锁在无竞争时避免CAS开销;轻量级锁通过自旋避免线程挂起;重量级锁仅在竞争激烈时启用。此外JIT编译器优化(锁消除、锁粗化)进一步提升性能,使synchronized在多数场景下性能优于ReentrantLock。