备案号:蜀ICP备2026035467号-3 | 网址:www.xservx.com

Java锁的面试题|并发编程核心考点全解析

深入剖析synchronized、ReentrantLock、StampedLock、读写锁等核心锁机制,结合真实面试题与源码级分析,覆盖锁升级、锁消除、公平性、性能对比、线程安全等高频考点,助您系统掌握Java并发编程关键技能。

立即查阅

一、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),但撤销后不再恢复偏向状态。

二、synchronized深度解析(高频考点)

1. synchronized的三种用法

  1. 实例方法锁:锁定当前实例对象(this)
  2. 静态方法锁:锁定Class对象(如MyClass.class)
  3. 代码块锁:显式指定锁对象(任意引用)

示例代码:

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);
            }
        }
    }
}

2. synchronized与内存可见性

synchronized不仅保证原子性,还确保内存可见性:

相当于隐式使用了volatile的内存屏障语义,但范围仅限同步块内变量。

3. synchronized常见陷阱

反例:

// 错误示例:每次拼接生成新String对象,锁对象不一致!
private String lock = "";
public void badExample() {
    synchronized (lock += "x") {  // 每次锁不同对象!
        // 临界区
    }
}

4. 面试高频题:synchronized vs volatile

维度 synchronized volatile
原子性 ✅ 保证复合操作原子性 ❌ 仅保证单次读/写原子性
可见性 ✅ ✅
有序性 ✅(happens-before) ✅(禁止指令重排)
阻塞 是(重量级锁) 否(仅内存屏障)
适用场景 多线程写、复合操作 单变量状态标志、状态发布

三、ReentrantLock:灵活与性能的平衡

1. 核心特性

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();
        }
    }
}

2. 公平锁 vs 非公平锁

非公平锁(默认):

公平锁:

源码关键差异:

// 非公平锁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;
}

3. 锁释放必须在finally中

反例(导致死锁):

// ❌ 错误:异常时未释放锁
lock.lock();
try {
    // 可能抛异常的操作
    riskyOperation();
    // 若异常发生,以下unlock不执行!
    lock.unlock();
}

✅ 正确写法:

lock.lock();
try {
    riskyOperation();
} finally {
    lock.unlock(); // 总在finally释放
}

4. 面试高频题:ReentrantLock vs synchronized

四、StampedLock:高性能读写锁新选择

1. 三种锁模式

  1. 写锁(writeLock):独占,阻塞所有读/写操作
  2. 悲观读锁(readLock):共享,阻塞写锁,类似ReentrantReadWriteLock
  3. 乐观读锁(tryOptimisticRead):非阻塞,返回时间戳;验证时若未被写则有效

核心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);
        }
    }
}

2. 锁转换(Lock Conversion)

支持三种转换(可能失败):

失败时返回0,需重新获取锁。

3.StampedLock注意事项

4.StampedLock vs ReadWriteLock

性能对比(读多写少场景):

指标 StampedLock ReentrantReadWriteLock
读吞吐量 极高(乐观读接近无锁) 中等
写吞吐量 中等 高
延迟波动 高(乐观读失败需重试) 低
适用场景 高吞吐、低延迟容忍场景 强一致性、稳定延迟场景

五、读写锁(ReentrantReadWriteLock)实战解析

1. 读写锁核心规则

典型应用场景:缓存更新

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();
        }
    }
}

2. 读写锁升级/降级问题

不支持读锁升级为写锁!否则导致死锁:

// ❌ 错误:读锁持有时尝试获取写锁 → 死锁
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();
}

3. 面试高频题:读写锁 vs synchronized

六、锁优化策略:从源码到实战

1. 锁消除(Lock Elimination)

JIT编译器通过逃逸分析(Escape Analysis)判断对象是否逃逸出线程:

示例:JDK 8中StringBuffer.append()被优化为无锁

// 编译后等效于:直接操作字符数组,无同步
StringBuffer sb = new StringBuffer();
sb.append("a").append("b").append("c"); // 等效于 sb.append("abc")

2. 锁粗化(Lock Coarsening)

JIT将多个连续加锁/解锁操作合并为一个大锁:

// 原始代码
for (int i = 0; i < 1000; i++) {
    synchronized(lock) {
        // 简单操作
    }
}
// 优化后等效于
synchronized(lock) {
    for (int i = 0; i < 1000; i++) {
        // 简单操作
    }
}

3. 偏向锁撤销(Bulk Revoke)

当多个线程竞争偏向锁时,JVM执行批量撤销:

  1. 暂停所有线程(STW)
  2. 检查偏向线程是否存活
  3. 若存活:升级为轻量级锁
  4. 若死亡:重置为无锁状态

可通过参数禁用偏向锁(JDK 15+默认禁用):

-XX:-UseBiasedLocking

4. 自旋锁优化

轻量级锁失败后,线程自旋等待(避免线程挂起开销):

参数调整:

-XX:PreBlockSpin=10      // 自旋次数
-XX:UseAdaptiveSpin=true // 启用自适应

5. 锁分段(Lock Striping)

将大锁拆分为多个小锁,降低竞争:

经典案例:ConcurrentHashMap(JDK 7)使用Segment数组:

// JDK 7 Segment结构
final Segment[] segments;
static final class Segment extends ReentrantLock { ... }

JDK 8改为CAS+synchronized组合,进一步降低锁粒度。

七、常见误区与避坑指南

1. 锁对象不一致

错误:使用可变对象作为锁

// ❌ 错误:this在继承中可能被覆盖
class Parent {
    synchronized void method() { ... }
}
class Child extends Parent {
    // 未重写,但锁对象变为this(子类实例)
}

正确:使用final私有锁对象

class SafeClass {
    private final Object lock = new Object();
    void safeMethod() {
        synchronized(lock) { ... }
    }
}

2. 死锁检测与预防

死锁四要素(需同时满足):

  1. 互斥条件
  2. 请求与保持
  3. 不可剥夺
  4. 循环等待

预防策略:

示例:银行转账死锁场景

// ❌ 错误:可能死锁
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;
        }
    }
}

3. 线程中断处理

在锁等待中响应中断:

// ✅ 正确:中断时清理资源
try {
    lock.lockInterruptibly();
    // 临界区
} catch (InterruptedException e) {
    // 恢复中断状态
    Thread.currentThread().interrupt();
    // 清理逻辑
    return;
} finally {
    if (lock.isHeldByCurrentThread()) {
        lock.unlock();
    }
}

八、高频面试题与答案要点

Q1:Java中有哪些锁类型?它们的适用场景是什么?

答:Java锁分为内置锁(synchronized)、显式锁(Lock实现类)和特殊锁(StampedLock)。synchronized适用于简单同步场景;ReentrantLock适用于需要中断、超时、公平性等高级功能的场景;StampedLock适用于读多写少且对延迟敏感的高性能场景。实际开发中应优先使用synchronized,仅在需要其不支持的功能时才选择其他锁。

Q2:synchronized的锁升级过程是怎样的?

答:synchronized锁升级路径为:无锁 → 偏向锁(单线程重复获取) → 轻量级锁(自旋竞争) → 重量级锁(多线程竞争激烈)。锁只能升级不能降级,偏向锁可被撤销(bulk rebias/revoke),但撤销后不再恢复偏向状态。JDK 15起默认禁用偏向锁以简化GC。

Q3:ReentrantLock如何实现可重入?

答:通过AQS的state变量记录锁持有次数。获取锁时,若state为0则CAS设置为1;若当前线程已持有锁(getExclusiveOwnerThread() == current),则state累加。释放锁时,state递减至0才真正释放。

Q4:StampedLock的乐观读如何保证数据一致性?

答:乐观读通过时间戳机制实现。获取锁时返回当前时间戳stamp;读取数据后调用validate(stamp)检查时间戳是否被写操作更新。若未更新,说明读期间无写入,数据有效;否则需升级为悲观读锁重新读取。该机制在无竞争时性能接近无锁,但可能因写操作频繁导致验证失败率高。

Q5:如何避免死锁?请给出具体策略。

答:死锁预防策略包括:① 固定加锁顺序(如按对象哈希码排序);② 使用tryLock+超时回退;③ 锁分级(Lock Ordering);④ 减少锁持有时间;⑤ 使用并发容器(如ConcurrentHashMap)替代手动加锁。实践中应优先选择无锁方案(如原子变量),其次考虑使用高级并发工具类。

Q6:synchronized与volatile的区别是什么?

答:synchronized保证原子性、可见性、有序性,但可能阻塞;volatile仅保证可见性和有序性(禁止指令重排),不保证原子性。synchronized适用于复合操作(如i++),volatile适用于状态标志(如boolean flag)。两者可结合使用:volatile确保状态发布,synchronized确保操作原子性。

Q7:为什么JDK 6后synchronized性能大幅提升?

答:JDK 6引入偏向锁和轻量级锁机制。偏向锁在无竞争时避免CAS开销;轻量级锁通过自旋避免线程挂起;重量级锁仅在竞争激烈时启用。此外JIT编译器优化(锁消除、锁粗化)进一步提升性能,使synchronized在多数场景下性能优于ReentrantLock。