02、Java并发编程:Lock接口

本文是 Java 并发编程系列的第二篇。上一篇我们梳理了线程与共享变量的基础问题,这一篇聚焦 JUC 包下最核心的同步工具------
Lock接口。文章会从线上真实事故的痛点场景切入,依次讲清楚 Lock 是什么、为什么需要它、它是怎么演进过来的、API 怎么用、底层 AQS 如何工作、企业项目里如何落地,并在最后给出与synchronized、ReentrantReadWriteLock、StampedLock的横向对比,以及面试官高频追问的问题。读完之后,小白也能直接在业务代码中正确使用显式锁。
文章目录
- 02、Java并发编程:Lock接口
-
- 一、痛点场景:线上库存超卖与锁泄漏事故
-
- [1.1 背景还原(STAR 之 S,Situation)](#1.1 背景还原(STAR 之 S,Situation))
- [1.2 任务与问题(STAR 之 T,Task)](#1.2 任务与问题(STAR 之 T,Task))
- [1.3 三个典型痛点拆解](#1.3 三个典型痛点拆解)
- [1.4 痛点解决方案总览](#1.4 痛点解决方案总览)
- [二、Lock 接口是什么(三维度解析)](#二、Lock 接口是什么(三维度解析))
-
- [2.1 专业解释](#2.1 专业解释)
- [2.2 大白话](#2.2 大白话)
- [2.3 生活案例](#2.3 生活案例)
- [2.4 Lock 接口体系结构](#2.4 Lock 接口体系结构)
- [三、为什么需要 Lock:synchronized 的短板](#三、为什么需要 Lock:synchronized 的短板)
-
- [3.1 synchronized 回顾](#3.1 synchronized 回顾)
- [3.2 Lock 补齐的四类能力](#3.2 Lock 补齐的四类能力)
- [3.3 大白话总结](#3.3 大白话总结)
- [四、演进历史:从内置监视器到 JUC 显式锁](#四、演进历史:从内置监视器到 JUC 显式锁)
-
- [4.1 JDK 1.0 到 1.4:内置锁一枝独秀](#4.1 JDK 1.0 到 1.4:内置锁一枝独秀)
- [4.2 JDK 1.5:JUC 与显式锁登场](#4.2 JDK 1.5:JUC 与显式锁登场)
- [4.3 JDK 1.6:内置锁反向优化](#4.3 JDK 1.6:内置锁反向优化)
- [4.4 JDK 1.8:StampedLock 补齐乐观读](#4.4 JDK 1.8:StampedLock 补齐乐观读)
- [4.5 现状与注意事项](#4.5 现状与注意事项)
- [五、Lock 核心 API 详解与代码实操](#五、Lock 核心 API 详解与代码实操)
-
- [5.1 标准加锁模板(Java 实现)](#5.1 标准加锁模板(Java 实现))
- [5.2 非阻塞尝试获取:tryLock()](#5.2 非阻塞尝试获取:tryLock())
- [5.3 限时获取:tryLock(long, TimeUnit)](#5.3 限时获取:tryLock(long, TimeUnit))
- [5.4 可中断获取:lockInterruptibly()](#5.4 可中断获取:lockInterruptibly())
- [5.5 编码契约:三条不可违反的规则](#5.5 编码契约:三条不可违反的规则)
- [六、底层原理:AQS 与 CLH 等待队列](#六、底层原理:AQS 与 CLH 等待队列)
-
- [6.1 AQS 是什么](#6.1 AQS 是什么)
- [6.2 获取锁的完整流程](#6.2 获取锁的完整流程)
- [6.3 可重入语义](#6.3 可重入语义)
- [6.4 公平锁与非公平锁](#6.4 公平锁与非公平锁)
- [七、企业项目实战(STAR 完整案例)](#七、企业项目实战(STAR 完整案例))
-
- [7.1 场景一:电商库存扣减](#7.1 场景一:电商库存扣减)
- [7.2 场景二:有界缓冲区生产者消费者(Condition 双条件队列)](#7.2 场景二:有界缓冲区生产者消费者(Condition 双条件队列))
- [7.3 场景三:读多写少的配置中心(读写锁)](#7.3 场景三:读多写少的配置中心(读写锁))
- [7.4 Spring 工程中的锁配置示例](#7.4 Spring 工程中的锁配置示例)
- [7.5 结果与收益(R)](#7.5 结果与收益(R))
- 八、竞品横向对比:四种锁的优劣势
-
- [8.1 选型建议](#8.1 选型建议)
- 九、常用业务场景清单
- 十、面试官高频面试题(附答题要点)
-
- [10.1 既然有了 synchronized,为什么还需要 Lock?](#10.1 既然有了 synchronized,为什么还需要 Lock?)
- [10.2 ReentrantLock 的底层实现是什么?](#10.2 ReentrantLock 的底层实现是什么?)
- [10.3 ReentrantLock 是公平锁还是非公平锁?默认是哪种?](#10.3 ReentrantLock 是公平锁还是非公平锁?默认是哪种?)
- [10.4 为什么 lock() 要放在 try 块外面,unlock() 放在 finally 里面?](#10.4 为什么 lock() 要放在 try 块外面,unlock() 放在 finally 里面?)
- [10.5 tryLock()、tryLock(time, unit)、lock()、lockInterruptibly() 有什么区别?](#10.5 tryLock()、tryLock(time, unit)、lock()、lockInterruptibly() 有什么区别?)
- [10.6 Condition 的 await/signal 与 Object 的 wait/notify 有什么区别?](#10.6 Condition 的 await/signal 与 Object 的 wait/notify 有什么区别?)
- [10.7 等待为什么必须用 while 循环而不是 if?](#10.7 等待为什么必须用 while 循环而不是 if?)
- [10.8 ReentrantReadWriteLock 和 StampedLock 的区别?](#10.8 ReentrantReadWriteLock 和 StampedLock 的区别?)
- [10.9 ReentrantLock 会不会死锁?如何避免?](#10.9 ReentrantLock 会不会死锁?如何避免?)
- [10.10 synchronized 和 ReentrantLock 在虚拟线程下有什么差异?](#10.10 synchronized 和 ReentrantLock 在虚拟线程下有什么差异?)
- 十一、避坑清单与最佳实践
- 十二、总结
一、痛点场景:线上库存超卖与锁泄漏事故
1.1 背景还原(STAR 之 S,Situation)
某电商大促期间,库存服务面向秒杀接口。后端使用一个 InventoryService 维护商品剩余库存,多个下单线程并发进入扣减逻辑。最初开发同学使用 synchronized 修饰扣减方法,本以为线程安全没有问题。
大促当天监控告警如下:
- 库存表中部分商品剩余数量变成负数,出现超卖;
- 个别请求长时间阻塞,线程堆栈全部停在等待同一把内置锁上,无法被中断;
- 一次灰度发布中,重构后的代码在扣减库存时抛出运行时异常,获取锁的线程崩溃退出后,其他线程全部永久阻塞,服务假死;
- 运营提出需求:高峰期只允许等待 200 毫秒,拿不到锁就直接返回"售罄",
synchronized没有提供任何超时入口。
1.2 任务与问题(STAR 之 T,Task)
作为接手该服务的开发,需要在不引入分布式锁的前提下,用单机 JVM 内的同步机制解决以下问题:
- 保证库存扣减的原子性,杜绝超卖;
- 锁等待必须可以被中断,便于优雅停机与线程池取消任务;
- 获取锁必须支持超时,避免请求无限阻塞拖垮服务;
- 锁必须在异常路径下也能被可靠释放;
- 在特定业务下需要区分"队列已满"和"队列已空"两类等待条件,唤醒时只通知对应的等待方。
1.3 三个典型痛点拆解
痛点一:synchronized 的等待过程不可中断、不可超时。 一旦线程排队等待内置监视器锁,外部调用 interrupt() 无法让它中途退出,synchronized 也没有"等 200 秒拿不到就放弃"的 API。线程池关闭、接口熔断时,这些线程会一直卡在入口处。
痛点二:显式锁如果忘记在 finally 中释放,会造成锁泄漏。 与 synchronized 由 JVM 在退出同步块时自动释放不同,Lock 是一把"手动开关的锁"。如果 lock() 之后业务代码抛出异常,而 unlock() 没有放在 finally 中,锁就永远不会释放,其他线程全部永久阻塞。
痛点三:一个对象监视器只能挂一个等待队列。 Object.wait()/notify() 所有等待线程共用同一个等待集合,notify() 随机唤醒一个,无法精确区分"等待不满的生产者"和"等待不空的消费者",容易出现错误唤醒甚至死锁。
1.4 痛点解决方案总览
上述问题恰好都是 java.util.concurrent.locks.Lock 接口及其实现类解决的范围:
lockInterruptibly()提供可中断的锁获取;tryLock(long timeout, TimeUnit unit)提供限时获取;unlock()配合finally保证异常路径释放;newCondition()支持多个独立等待条件队列;- 实现类
ReentrantLock还支持公平锁与非公平锁两种策略选择。
二、Lock 接口是什么(三维度解析)
2.1 专业解释
Lock 是 java.util.concurrent.locks 包下定义的一个同步接口,位于 JDK 1.5 引入的 JUC 框架中。它为"互斥锁"抽象出一套显式的加锁与解锁契约:线程在进入临界区之前调用加锁方法获取锁,离开临界区时调用解锁方法释放锁;锁对象在同一时刻最多只被一个线程持有,从而保证临界区代码的互斥执行。
接口的全部方法签名如下:
java
public interface Lock {
// 获取锁,阻塞直到拿到
void lock();
// 获取锁,等待过程可被中断
void lockInterruptibly() throws InterruptedException;
// 尝试非阻塞获取,拿到返回 true,拿不到返回 false
boolean tryLock();
// 限时获取,在指定时间内未拿到返回 false
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
// 释放锁
void unlock();
// 绑定一个条件等待队列
Condition newCondition();
}
与 synchronized 基于对象头 Mark Word 和监视器(Monitor)的隐式同步不同,Lock 是普通 Java 对象上的显式 API,加锁与解锁动作由代码显式调用,锁的持有状态、等待队列、唤醒策略都由实现类自行管理。
2.2 大白话
synchronized 像公共厕所门上那种自动锁:你进门,门自动锁上;你出来,门自动弹开,你不需要记得任何开关动作。Lock 则像一把手动挂锁:进门之前你自己把锁挂上,出门之后你自己把锁摘掉。挂锁可以选择"等不及就走"(tryLock)、"别人喊我走我就走"(lockInterruptibly),还能在锁上挂多把不同的等待号码牌(多个 Condition)。代价是你必须记得出门摘锁,忘了摘,后面所有人都进不去。
2.3 生活案例
写字楼电梯口的等候人群可以类比锁的竞争:
- 一部电梯同一时间只载一组人,这就是互斥;
- 先到先排、依次进入,是公平锁;
- 有人看到电梯门正好打开就直接挤进去插队,是非公平锁;
- 高峰期等待电梯超过 30 秒就改走楼梯,对应
tryLock超时放弃; - 火警铃响起,所有等待者立刻疏散,对应可中断获取;
- 大堂经理分两条队伍登记:"满员等候"队伍和"空位等候"队伍,对应两个
Condition条件队列。
2.4 Lock 接口体系结构

JUC 锁体系中与 Lock 直接相关的成员:
Lock:顶层互斥锁接口;ReentrantLock:可重入互斥锁,Lock最常用的实现;ReadWriteLock:读写锁接口,维护一对读锁与写锁;ReentrantReadWriteLock:读写锁的可重入实现;StampedLock:JDK 8 引入的读写锁增强版,支持乐观读;Condition:与锁绑定的条件等待对象,替代Object的等待唤醒机制。
三、为什么需要 Lock:synchronized 的短板
3.1 synchronized 回顾
synchronized 可以修饰实例方法、静态方法或代码块,底层依赖对象监视器。它具备可重入语义:持有锁的线程再次进入同锁同步块不会被自己阻塞。JDK 6 之后,内置锁经过偏向锁、轻量级锁、自旋、锁消除、锁粗化等一系列优化,在低竞争场景下性能已经与显式锁接近。
3.2 Lock 补齐的四类能力
| 能力维度 | synchronized | Lock 接口 |
|---|---|---|
| 获取锁是否可中断 | 等待中不响应中断 | lockInterruptibly() 响应中断 |
| 获取锁是否可超时 | 不支持 | tryLock(time, unit) 支持限时 |
| 非阻塞尝试获取 | 不支持,拿不到就进入阻塞 | tryLock() 立即返回布尔值 |
| 等待条件队列 | 每个对象只有一个等待集合 | 一个锁可绑定多个 Condition |
| 公平性选择 | 非公平 | 构造时可选公平或非公平 |
| 锁释放方式 | JVM 退出同步块自动释放 | 代码显式调用 unlock(),须配合 finally |
3.3 大白话总结
synchronized 是省心但不够灵活的自动挡:日常通勤足够用,但你不能手动干预换挡。Lock 是手动挡:操作步骤更多、对开发者要求更高,但可中断、可超时、多条件等待、公平性可选这些精细控制,自动挡给不了。二者不是替代关系,而是按场景选择。
四、演进历史:从内置监视器到 JUC 显式锁
理解 Lock 为什么长今天这个样子,需要回顾 Java 同步机制的四个阶段。
4.1 JDK 1.0 到 1.4:内置锁一枝独秀
早期 Java 唯一的线程同步手段就是 synchronized,配套 Object 的 wait/notify/notifyAll。所有跨线程协作都围绕对象监视器展开。这一时期内置锁性能较差:竞争时线程进入阻塞依赖操作系统内核态线程挂起与唤醒,上下文切换成本高;且不支持中断等待、不支持超时,工程上容易出现长时间阻塞。
4.2 JDK 1.5:JUC 与显式锁登场
Doug Lea 主导的 java.util.concurrent 包随 JDK 1.5 发布,Lock、ReadWriteLock、Condition 接口,以及 ReentrantLock、ReentrantReadWriteLock、AbstractQueuedSynchronizer(AQS)第一次进入标准库。显式锁基于 volatile 状态变量、CAS 自旋和 FIFO 等待队列实现,在竞争场景下显著降低了内核态切换开销,同时补齐了可中断、超时、多条件等待等能力。
4.3 JDK 1.6:内置锁反向优化
为了缩小与显式锁的差距,JDK 1.6 对 synchronized 做了大量优化:引入偏向锁、轻量级锁、自适应自旋、锁消除、锁粗化,并改进对象头 Mark Word 的记录方式。无竞争或低竞争时,内置锁的开销大幅下降;锁升级路径从无锁到偏向锁、轻量级锁、重量级锁逐级进行。这也是今天很多场景下 synchronized 依然是首选的历史原因。
4.4 JDK 1.8:StampedLock 补齐乐观读
JDK 8 引入 StampedLock,在读写锁基础上增加乐观读(乐观读不加读锁,读完后校验票据是否被写操作修改),进一步提升读多写少场景的并发度。它不可重入,也不支持 Condition,属于面向特定场景的特化工具。
4.5 现状与注意事项
当前 JDK 中 synchronized 与 Lock 并存。低竞争、简单互斥的代码优先使用 synchronized;需要可中断、超时、多条件等待或公平性控制时使用 ReentrantLock。另外在虚拟线程(Project Loom)场景下,synchronized 临界区内的阻塞会导致载体线程钉住(pinning),而 ReentrantLock 在后续版本中已缓解该问题;编写面向虚拟线程的代码时需要把这一差异纳入评估。
五、Lock 核心 API 详解与代码实操
5.1 标准加锁模板(Java 实现)
ReentrantLock 是 Lock 接口最基础、最常用的实现。下面是生产代码中必须遵守的标准模板:lock() 放在 try 块之外,unlock() 放在 finally 块的第一行。
java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Counter {
private final Lock lock = new ReentrantLock();
private long count = 0;
public void increment() {
lock.lock(); // 加锁必须在 try 之外,避免未拿到锁却在 finally 中误释放
try {
count++; // 临界区代码
} finally {
lock.unlock(); // 解锁必须在 finally,保证异常路径也释放锁
}
}
public long getCount() {
return count;
}
}
对应的 Python 对照实现。Python 标准库 threading.Lock 同样是显式互斥锁,语义上与 ReentrantLock 的不可重入版本接近;Python 的可重入锁为 threading.RLock。
python
import threading
class Counter:
def __init__(self):
self._lock = threading.Lock()
self._count = 0
def increment(self):
# acquire 对应 lock(),release 对应 unlock()
self._lock.acquire()
try:
self._count += 1
finally:
self._lock.release()
def get_count(self):
return self._count
5.2 非阻塞尝试获取:tryLock()
tryLock() 不等待:拿到锁立即返回 true,拿不到立即返回 false。适合"抢不到就做别的事"的场景,例如定时任务抢锁执行。
java
import java.util.concurrent.locks.ReentrantLock;
public class TryLockDemo {
private final ReentrantLock lock = new ReentrantLock();
public void tryTask() {
if (lock.tryLock()) {
try {
System.out.println("拿到锁,执行业务");
} finally {
lock.unlock();
}
} else {
System.out.println("未拿到锁,直接跳过或执行降级逻辑");
}
}
}
Python 对照实现,acquire(blocking=False) 即非阻塞获取:
python
import threading
class TryLockDemo:
def __init__(self):
self._lock = threading.Lock()
def try_task(self):
if self._lock.acquire(blocking=False):
try:
print("拿到锁,执行业务")
finally:
self._lock.release()
else:
print("未拿到锁,直接跳过或执行降级逻辑")
5.3 限时获取:tryLock(long, TimeUnit)
限时获取是解决"请求无限阻塞"的核心 API。在指定时间内拿到锁返回 true,超时返回 false;等待过程中被中断则抛出 InterruptedException。
java
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
public class TimeoutLockDemo {
private final ReentrantLock lock = new ReentrantLock();
public boolean deductStock() throws InterruptedException {
// 最多等待 200 毫秒,拿不到锁就返回 false,由上层降级处理
if (lock.tryLock(200, TimeUnit.MILLISECONDS)) {
try {
// 扣减库存的临界区逻辑
return true;
} finally {
lock.unlock();
}
}
return false;
}
}
Python 对照实现,acquire(timeout=0.2) 对应限时获取:
python
import threading
class TimeoutLockDemo:
def __init__(self):
self._lock = threading.Lock()
def deduct_stock(self):
# 最多等待 0.2 秒,拿不到锁返回 False
if self._lock.acquire(timeout=0.2):
try:
return True
finally:
self._lock.release()
return False
5.4 可中断获取:lockInterruptibly()
普通 lock() 等待期间不响应中断;lockInterruptibly() 在等待队列中收到中断信号时会立即抛出 InterruptedException,线程可以退出等待、做资源清理后结束。在线程池 shutdownNow()、任务取消等场景中必须使用它。
java
import java.util.concurrent.locks.ReentrantLock;
public class InterruptibleLockDemo {
private final ReentrantLock lock = new ReentrantLock();
public void task() throws InterruptedException {
lock.lockInterruptibly();
try {
// 临界区逻辑
} finally {
lock.unlock();
}
}
}
调用方需要妥善处理中断:捕获 InterruptedException 后,通常应通过 Thread.currentThread().interrupt() 恢复中断标记,再向上层传播,避免中断状态被吞掉。
5.5 编码契约:三条不可违反的规则
lock()、lockInterruptibly()、tryLock返回true之后,才必须调用unlock();未拿到锁时调用unlock()会抛出IllegalMonitorStateException。unlock()必须放在finally块中,且通常作为finally的第一条语句,保证任何异常路径都能释放锁。- 加锁范围尽量小:只保护共享可变状态的临界区,不要把远程调用、数据库事务、耗时 IO 放进锁内,否则会严重降低并发度并增加死锁风险。
六、底层原理:AQS 与 CLH 等待队列

6.1 AQS 是什么
ReentrantLock 等 JUC 同步器的共同底座是 AbstractQueuedSynchronizer(AQS)。它提供三个核心构件:
state:一个volatile int类型的同步状态。在ReentrantLock中,0表示无锁,大于0表示当前线程持有锁的重入次数;- CLH 变体的 FIFO 双向队列:存放获取锁失败而被阻塞的等待线程节点;
- CAS 操作:通过
compareAndSetState原子地修改状态,避免加锁过程本身的并发问题。
6.2 获取锁的完整流程
- 线程尝试用 CAS 修改
state:无锁时把0改为1; - 如果 CAS 成功,记录当前持有锁的线程,获取成功;
- 如果当前线程就是已持锁线程(可重入场景),
state加 1; - 如果 CAS 失败,线程被包装成队列节点加入 CLH 队列尾部;
- 队列中的节点等待前驱节点唤醒,被唤醒后再次尝试 CAS;
- 释放锁时
state减 1,减到0时唤醒队列中后继节点。
6.3 可重入语义
ReentrantLock 的"可重入"体现在:持有锁的线程再次进入同锁临界区时,不需要阻塞,只需把 state 累加;退出时逐层递减,只有最后一次退出把 state 降为 0 才真正释放锁。这与 synchronized 的重入行为一致。
6.4 公平锁与非公平锁

ReentrantLock 构造时可以选择两种策略:
java
// 非公平锁(默认)
Lock nonFair = new ReentrantLock();
// 公平锁
Lock fair = new ReentrantLock(true);
- 非公平锁:新线程到来时先直接 CAS 抢一次锁,抢不到再排队。允许"插队",减少线程挂起与唤醒的开销,吞吐量更高,但队列中的线程可能长时间得不到锁;
- 公平锁:任何线程获取锁前先检查队列中是否有前驱等待节点,有则排队,严格 FIFO。等待时间可预测,但上下文切换更多,吞吐量略低。
生产环境绝大多数场景使用默认非公平锁;只有业务明确要求等待顺序公平(例如严格按请求顺序分配资源)时才开启公平锁。
七、企业项目实战(STAR 完整案例)
7.1 场景一:电商库存扣减
背景(S) :秒杀接口并发扣减商品库存,库存为共享可变成员变量。
任务(T) :保证扣减原子性,杜绝超卖;拿不到锁限时降级,不允许线程无限阻塞。
行动(A) :使用 ReentrantLock 保护库存读取与扣减的复合操作,tryLock 设置超时,临界区只包含内存状态更新,扣减成功后再落库。
java
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
public class InventoryService {
private final ReentrantLock lock = new ReentrantLock();
private int stock;
public InventoryService(int stock) {
this.stock = stock;
}
public boolean deduct(int quantity) throws InterruptedException {
if (!lock.tryLock(200, TimeUnit.MILLISECONDS)) {
// 排队超时,上层返回"售罄"或稍后重试
return false;
}
try {
if (stock < quantity) {
return false;
}
stock -= quantity;
// 此处仅演示内存扣减;真实项目在锁内更新库存后,事务与持久化在锁外编排
return true;
} finally {
lock.unlock();
}
}
public int remaining() {
return stock;
}
}
Python 对照实现,使用 threading.Lock 与超时获取:
python
import threading
class InventoryService:
def __init__(self, stock: int):
self._lock = threading.Lock()
self._stock = stock
def deduct(self, quantity: int) -> bool:
if not self._lock.acquire(timeout=0.2):
return False
try:
if self._stock < quantity:
return False
self._stock -= quantity
return True
finally:
self._lock.release()
def remaining(self) -> int:
return self._stock
7.2 场景二:有界缓冲区生产者消费者(Condition 双条件队列)
背景(S) :订单解析模块中,生产者线程写入解析任务,消费者线程取出执行,缓冲区容量固定为 5。
任务(T) :缓冲区满时生产者等待,缓冲区空时消费者等待;唤醒必须精准,不能让生产者唤醒生产者、消费者唤醒消费者。
行动(A) :一把 ReentrantLock 绑定两个 Condition:notFull 管理生产者等待,notEmpty 管理消费者等待。

java
import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class BoundedBuffer<T> {
private final Queue<T> queue = new LinkedList<>();
private final int capacity;
private final ReentrantLock lock = new ReentrantLock();
private final Condition notFull = lock.newCondition();
private final Condition notEmpty = lock.newCondition();
public BoundedBuffer(int capacity) {
this.capacity = capacity;
}
public void put(T item) throws InterruptedException {
lock.lock();
try {
// 必须用 while 而非 if,防止被唤醒后条件已被其他线程改变
while (queue.size() == capacity) {
notFull.await(); // 释放锁并进入 notFull 等待队列
}
queue.add(item);
notEmpty.signal(); // 唤醒一个等待"非空"的消费者
} finally {
lock.unlock();
}
}
public T take() throws InterruptedException {
lock.lock();
try {
while (queue.isEmpty()) {
notEmpty.await();
}
T item = queue.poll();
notFull.signal(); // 唤醒一个等待"非满"的生产者
return item;
} finally {
lock.unlock();
}
}
}
Python 对照实现,使用 threading.Condition,其 wait/notify 语义与 Condition.await/signal 一一对应:
python
import threading
from collections import deque
class BoundedBuffer:
def __init__(self, capacity: int):
self._queue = deque(maxlen=capacity)
self._lock = threading.Condition()
def put(self, item):
with self._lock:
while len(self._queue) == self._queue.maxlen:
self._lock.wait()
self._queue.append(item)
self._lock.notify()
def take(self):
with self._lock:
while not self._queue:
self._lock.wait()
item = self._queue.popleft()
self._lock.notify()
return item
两个关键细节:等待判断必须用 while 循环而不是 if,因为线程被唤醒后、重新拿到锁之前,条件可能已被其他线程再次改变;signal 只唤醒对应条件队列中的一个等待者,signalAll 唤醒全部。
7.3 场景三:读多写少的配置中心(读写锁)
背景(S) :系统配置注册中心,配置项被大量线程读取,只有管理员偶尔更新。
任务(T) :读读并发、读写互斥、写写互斥,避免一把独占锁把读请求全部串行化。
行动(A) :使用 ReentrantReadWriteLock,读操作获取读锁(共享),写操作获取写锁(独占)。
java
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ConfigCenter {
private final Map<String, String> config = new ConcurrentHashMap<>();
private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
public String get(String key) {
rwLock.readLock().lock();
try {
return config.get(key);
} finally {
rwLock.readLock().unlock();
}
}
public void put(String key, String value) {
rwLock.writeLock().lock();
try {
config.put(key, value);
} finally {
rwLock.writeLock().unlock();
}
}
}
7.4 Spring 工程中的锁配置示例
在 Spring 业务服务中,锁对象通常作为 Bean 注入,避免每个工具类各自 new 一把锁。下面是配套的配置写法,先给出 yaml 配置,再给出 Java 配置类。
yaml
app:
lock:
# fair=false 使用非公平锁;true 为公平锁
fair: false
# 获取锁超时时间,毫秒
acquire-timeout-ms: 200
java
import java.util.concurrent.locks.ReentrantLock;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class LockConfig {
@Value("${app.lock.fair:false}")
private boolean fair;
@Bean
public ReentrantLock businessLock() {
return new ReentrantLock(fair);
}
}
使用时通过构造器注入 ReentrantLock,而不是在业务方法内新建,保证同一共享状态对应的是同一把锁。
7.5 结果与收益(R)
上线改造后:库存扣减链路未再出现超卖;排队超时使慢请求在 200 毫秒内降级,线程池水位恢复正常;Condition 双条件队列消除了错误唤醒;配置中心读接口在读写锁下吞吐量显著高于独占锁版本。同时统一的加锁模板纳入代码评审规范,异常路径的锁泄漏问题不再出现。
八、竞品横向对比:四种锁的优劣势

| 对比维度 | synchronized | ReentrantLock | ReentrantReadWriteLock | StampedLock |
|---|---|---|---|---|
| 引入版本 | JDK 1.0 | JDK 1.5 | JDK 1.5 | JDK 1.8 |
| 锁类型 | 独占悲观锁 | 独占可重入锁 | 读写分离锁(读共享、写独占) | 读写锁增强,含乐观读 |
| 是否可重入 | 是 | 是 | 读锁写锁均可重入 | 不可重入 |
| 可中断获取 | 否 | 是(lockInterruptibly) | 读锁写锁均可中断 | 支持中断获取 |
| 超时获取 | 否 | 是(tryLock) | 是(tryLock) | 是(tryConvertToWriteLock 等) |
| 多条件队列 | 单一等待集合 | 多个 Condition | 多个 Condition | 不支持 Condition |
| 公平性可选 | 仅非公平 | 可选公平或非公平 | 可选公平或非公平 | 仅非公平 |
| 乐观读 | 不支持 | 不支持 | 不支持 | 支持,读完校验票据 |
| 语法成本 | 低,JVM 自动释放 | 中,须手动 unlock 并配合 finally | 中,两把锁分别管理 | 较高,票据语义需仔细处理 |
| 适用场景 | 简单互斥、低竞争临界区 | 需要中断、超时、公平性、多条件队列 | 读多写少的缓存、配置、元数据 | 读极多写极少、可接受乐观读校验的场景 |
8.1 选型建议
- 代码只需要简单互斥、没有特殊控制需求:优先
synchronized; - 需要可中断、超时、非阻塞尝试、公平锁或多个等待条件:选
ReentrantLock; - 读多写少,且读操作远多于写操作:选
ReentrantReadWriteLock; - 读并发压力极大,读临界区很短,能接受乐观读失败后重读:选
StampedLock; - 任何情况下都要避免锁嵌套顺序不一致导致的死锁,并尽量缩小锁粒度。
九、常用业务场景清单
- 库存与计数器:保护"读取判断再更新"的复合操作,保证扣减原子性;
- 任务队列与缓冲区 :生产者消费者模型,用两个
Condition分离满与空的等待; - 缓存与配置中心:读多写少场景使用读写锁提升读并发;
- 单例初始化与共享工具类:保护静态或单例对象中的可变状态;
- 串行化外部资源访问:保护非线程安全的第三方客户端、文件句柄、打印任务;
- 限时降级 :
tryLock超时后走兜底逻辑,防止请求堆积; - 优雅停机 :
lockInterruptibly让等待锁的任务能响应线程中断,配合线程池关闭; - 公平调度:严格按到达顺序分配资源的任务队列,使用公平锁保证顺序。
十、面试官高频面试题(附答题要点)
10.1 既然有了 synchronized,为什么还需要 Lock?
答题要点:synchronized 等待不可中断、不可超时、只有单一等待队列、无法选择公平性;Lock 提供 lockInterruptibly、限时 tryLock、多个 Condition、公平锁选项,显式释放也带来更灵活的锁控制。二者互补,不是替代。
10.2 ReentrantLock 的底层实现是什么?
答题要点:基于 AQS。核心是 volatile int state 表示同步状态与重入次数,CLH 变体 FIFO 双向队列管理等待线程,CAS 修改状态,持锁线程记录在 AbstractOwnableSynchronizer 中;释放时状态递减,归零后唤醒后继节点。
10.3 ReentrantLock 是公平锁还是非公平锁?默认是哪种?
答题要点:两种都支持,构造参数 fair 控制;默认非公平锁。非公平允许新线程先 CAS 抢锁,吞吐量更高;公平锁严格 FIFO,等待顺序可预测但性能略低。
10.4 为什么 lock() 要放在 try 块外面,unlock() 放在 finally 里面?
答题要点:如果 lock() 在 try 内且加锁失败抛异常,finally 仍会执行 unlock(),此时线程并未持有锁,会抛出 IllegalMonitorStateException。lock() 放 try 外,只有确认拿到锁后才进入 try;unlock() 放 finally 第一行,保证临界区抛出任何异常都能释放锁。
10.5 tryLock()、tryLock(time, unit)、lock()、lockInterruptibly() 有什么区别?
答题要点:lock() 阻塞等待且不响应中断;lockInterruptibly() 阻塞等待但响应中断并抛 InterruptedException;tryLock() 非阻塞立即返回布尔值;tryLock(time, unit) 限时等待,超时返回 false,等待中可被中断。
10.6 Condition 的 await/signal 与 Object 的 wait/notify 有什么区别?
答题要点:一个 Lock 可以创建多个 Condition,每个条件对应独立等待队列,可以精确唤醒某一类等待线程;Object 只有一个等待集合,notify 随机唤醒。await 会释放锁并在被唤醒后重新竞争锁,语义与 wait 对应,但绑定在显式锁之上。
10.7 等待为什么必须用 while 循环而不是 if?
答题要点:线程被唤醒后到重新持有锁之间,条件可能已被其他线程改变(虚假唤醒或多个等待者竞争)。用 while 在重新拿到锁后再次检查条件,不满足则继续等待;用 if 会跳过二次检查,导致条件已不满足仍执行临界区逻辑。
10.8 ReentrantReadWriteLock 和 StampedLock 的区别?
答题要点:读写锁读共享写独占,可重入,支持 Condition;StampedLock 在 JDK 8 引入,支持乐观读(不加读锁,读完校验票据),并发度更高,但不可重入、不支持 Condition,票据转换使用不当容易出错,适合读极多写极少的短临界区。
10.9 ReentrantLock 会不会死锁?如何避免?
答题要点:会。锁嵌套顺序不一致、持锁期间永久阻塞、忘记释放锁都可能导致死锁。避免方式:固定加锁顺序、缩小锁粒度、使用 tryLock 超时放弃、保证 unlock 在 finally、避免持锁时调用外部未知回调。
10.10 synchronized 和 ReentrantLock 在虚拟线程下有什么差异?
答题要点:JDK 早期版本中,synchronized 临界区内阻塞会钉住载体线程;ReentrantLock 已在后续版本中缓解钉住问题。面向虚拟线程的高并发服务需要结合 JDK 版本评估锁内阻塞行为,必要时把阻塞操作移出临界区。
十一、避坑清单与最佳实践
- 永远不要把
unlock()写在普通代码路径,必须放进finally; - 未成功获取锁时不要调用
unlock(),否则抛出监视器状态异常; - 临界区只保护共享可变状态,远程调用、事务、IO 不要放进锁内;
- 多把锁时全局约定加锁顺序,避免交叉持锁;
- 优先非公平锁,除非业务明确要求公平顺序;
- 使用
Condition时坚持while循环检查条件; - 捕获
InterruptedException后恢复中断标记,不要吞掉中断状态; - 锁对象声明为
final,避免引用被替换导致不同线程使用不同的锁; - 低竞争简单场景优先
synchronized,不要为了用 Lock 而用 Lock; - 并发问题优先从"是否真的需要共享可变状态"思考,不可变对象与线程局部变量是更彻底的并发方案。
十二、总结
Lock 接口是 JUC 显式锁体系的契约入口:lock、unlock 定义基础互斥,tryLock 提供非阻塞与限时获取,lockInterruptibly 响应中断,newCondition 提供多条件等待。它的主流实现 ReentrantLock 基于 AQS 的 state、CAS 与 FIFO 等待队列实现可重入互斥,并支持公平与非公平两种策略;读写锁与 StampedLock 则面向读多写少场景提供更高的并发度。
工程实践中的判断标准很清晰:简单互斥用 synchronized;需要精细控制(中断、超时、公平、多条件)用 ReentrantLock;读多写少用读写锁或 StampedLock。无论使用哪一种锁,缩小临界区、保证异常路径释放、固定加锁顺序,都是必须守住的底线。
本文为原创文章,如需转载,请联系作者获得授权,并注明出处。