一、概述
本文基于课程内容整理 Java 并发编程中三个紧密关联的核心知识点:管程(Monitor) 、AQS(AbstractQueuedSynchronizer) 与 ReentrantLock。三者构成一条完整的主线:管程是并发同步的设计思想,AQS 是这一思想在 Java 中的通用框架实现,ReentrantLock 则是基于 AQS 落地的具体锁实现。
核心主线:设计思想(管程)→ 通用框架(AQS)→ 具体实现(ReentrantLock)。理解这条主线,就能把零散的 API 和源码串成体系。
二、管程:Java 同步的设计思想
2.1 三个基础概念
- 管程:管理共享变量以及对共享变量的操作过程,让它们支持并发。
- 互斥:同一时刻只允许一个线程访问共享资源。
- 同步:线程之间如何通信、协作。
简单来说,互斥解决"不能同时进"的问题,同步解决"谁先谁后、如何通知"的问题。管程把这两件事封装在一起,对外提供统一的并发控制入口。
2.2 Java 中管程的两种实现
| 实现方式 | 对应机制 | 典型应用 |
|---|---|---|
| 基于 Object 的 Monitor 机制 | 对象头 Mark Word + Monitor | synchronized 内置锁 |
| 抽象队列同步器 AQS | state + CLH 队列 + 条件队列 | JUC 包下的 Lock 锁机制 |
示例:Condition 的 await / signalAll
下面示例演示两个线程在同一个 Condition 上等待,主线程 2 秒后唤醒它们:
java
@Slf4j
public class ConditionDemo2 {
private static final ReentrantLock lock = new ReentrantLock();
private static final Condition condition = lock.newCondition();
public static void main(String[] args) throws InterruptedException {
new Thread(() -> {
log.debug("t1开始执行....");
lock.lock();
try {
log.debug("t1获取锁....");
// 让线程在obj上一直等待下去
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
log.debug("t1执行完成....");
}
}, "t1").start();
new Thread(() -> {
log.debug("t2开始执行....");
lock.lock();
try {
log.debug("t2获取锁....");
// 让线程在obj上一直等待下去
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
log.debug("t2执行完成....");
}
}, "t2").start();
// 主线程两秒后执行
Thread.sleep(2000);
log.debug("准备获取锁,去唤醒 condition上阻塞的线程");
lock.lock();
try {
// 唤醒condition上所有阻塞的线程
condition.signalAll();
log.debug("唤醒condition上阻塞的线程");
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
要点:await() 会释放锁并进入条件队列,signalAll() 只是把条件队列中的节点转移到同步队列,被唤醒线程仍需重新竞争锁才能继续执行。
三、AQS 原理
3.1 什么是 AQS
JUC 包中的大多数同步器实现都围绕共同的基础行为:等待队列、条件队列、独占获取、共享获取 。这些行为的抽象就是 AbstractQueuedSynchronizer(AQS)。AQS 是一个抽象同步框架,可以用来实现一个依赖状态的同步器。
JDK 中大多数同步器,如 Lock、Latch、Barrier 等,都是基于 AQS 框架实现的。一般做法是通过一个内部类 Sync 继承 AQS,将同步器的所有调用映射到 Sync 对应的方法上。
**AQS 具备的特性:**阻塞等待队列、共享 / 独占、公平 / 非公平、可重入、允许中断
3.2 核心结构:volatile int state
AQS 内部维护属性 volatile int state,表示资源的可用状态,使用 volatile 修饰保证线程可见性。state 有三种访问方式:getState()、setState()、compareAndSetState()
java
private volatile int state;//共享变量,使用volatile修饰保证线程可见性
//返回同步状态的当前值
protected final int getState() {
return state;
}
// 设置同步状态的值
protected final void setState(int newState) {
state = newState;
}
//原子地(CAS操作)将同步状态值设置为给定值update如果当前同步状态的值等于expect(期望值)
protected final boolean compareAndSetState(int expect, int update) {
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
两种资源访问方式
- Exclusive(独占):只有一个线程能执行,如 ReentrantLock。
- Share(共享):多个线程可以同时执行,如 Semaphore、CountDownLatch。
3.3 需要子类实现的方法
| 方法 | 说明 |
|---|---|
isHeldExclusively() |
该线程是否正在独占资源,只有用到 Condition 才需要实现 |
tryAcquire(int) |
独占方式尝试获取资源,成功返回 true,失败返回 false |
tryRelease(int) |
独占方式尝试释放资源,成功返回 true,失败返回 false |
tryAcquireShared(int) |
共享方式尝试获取资源,负数表示失败,0 表示成功但无剩余资源,正数表示成功且有剩余资源 |
tryReleaseShared(int) |
共享方式尝试释放资源,若释放后允许唤醒后续等待节点返回 true,否则返回 false |
3.4 AQS 定义两种队列
同步等待队列(CLH 队列):由 Craig、Landin、Hagersten 三人发明,是基于双向链表数据结构的队列,是 FIFO 先进先出线程等待队列。Java 中的 CLH 队列是原 CLH 队列的变种,线程由原自旋机制改为阻塞机制。
- 当前线程获取同步状态失败时,AQS 会将当前线程及等待状态等信息构造成一个 Node 节点,加入 CLH 同步队列,同时阻塞当前线程。
- 当同步状态释放时,会把首节点唤醒(公平锁),使其再次尝试获取同步状态。

条件等待队列 :使用单向列表保存,用 nextWaiter 连接。
- 调用
await()时释放锁,线程加入条件队列。 - 调用
signal()唤醒时,把条件队列中的线程节点移动到同步队列中,等待再次获得锁。

3.5 节点状态(5 种)
| 状态 | 值 | 含义 |
|---|---|---|
| 默认状态 | 0 | 初始化状态,表示当前节点在 sync 队列中等待获取锁 |
| CANCELLED | 1 | 当前线程被取消 |
| SIGNAL | -1 | 当前节点的后继节点包含的线程需要运行,即 unpark |
| CONDITION | -2 | 当前节点在等待 condition,即在 condition 队列中 |
| PROPAGATE | -3 | 当前场景下后续的 acquireShared 能够得以执行 |
3.6 基于 AQS 实现一把独占锁
java
/**
* 基于 AQS 实现一把独占锁
*/
public class TulingLock extends AbstractQueuedSynchronizer {
@Override
protected boolean tryAcquire(int unused) {
// CAS 加锁,state 由 0 改为 1
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
@Override
protected boolean tryRelease(int unused) {
// 释放锁
setExclusiveOwnerThread(null);
setState(0);
return true;
}
public void lock() {
acquire(1);
}
public boolean tryLock() {
return tryAcquire(1);
}
public void unlock() {
release(1);
}
public boolean isLocked() {
return getState() != 0;
}
}
这段代码体现了 AQS 的模板方法设计:加锁/释放锁的骨架由 AQS 提供,子类只需实现 tryAcquire / tryRelease 决定"能否获取/释放"。
四、ReentrantLock原理
4.1 核心定位与特点
ReentrantLock 是一种可重入的独占锁 ,允许同一个线程多次获取同一个锁而不会被阻塞。它的功能类似于 synchronized,是一种互斥锁,用于保证线程安全。主要应用场景是在多线程环境下对共享资源进行独占式访问 ,以保证数据的一致性和安全性。它基于 AQS + CAS 实现。
相对于 synchronized,ReentrantLock 具备以下特点:
- 可中断:获取锁的过程可以响应中断。
- 可设置超时时间:避免无限等待。
- 可设置为公平锁:按等待顺序获取锁。
- 支持多个条件变量:一个锁可以绑定多个 Condition。
- 支持可重入:与 synchronized 一致。
工作原理(AQS 简述)
当有线程调用 lock 方法时:如果线程获取到锁,就会通过 CAS 的方式把 AQS 内部的 state 设置为 1,此时当前线程就获取到锁了。只有首部节点(head 节点封装的线程)可以获取到锁,其他线程都会加入到阻塞队列中。
- 公平锁 :head 节点释放锁后,会优先唤醒
head.next节点对应的线程。线程在获取锁时,按照等待的先后顺序获取锁。 - 非公平锁:允许新来的线程和 head 之后被唤醒的线程通过 CAS 竞争锁。ReentrantLock 默认是非公平锁。
java
ReentrantLock lock = new ReentrantLock(); // 参数默认 false,非公平锁
ReentrantLock lock = new ReentrantLock(true); // 公平锁
可重入锁
又名递归锁,指在同一个线程在外层方法获取锁的时候,再进入该线程的内层方法会自动获取锁(前提锁对象得是同一个对象),不会因为之前已经获取过还没释放而阻塞。Java 中 ReentrantLock 和 synchronized 都是可重入锁,可重入锁的一个优点是可一定程度避免死锁。实际开发中常用于递归操作、调用同一个类中的其他方法、锁嵌套等场景。
4.2 类结构
- Sync:ReentrantLock 的抽象静态内部类,继承自 AQS,AQS 中用 volatile 修饰的 state 表示当前锁重入的次数。
- NonfairSync:继承 Sync,实现非公平锁。
- FairSync:继承 Sync,实现公平锁。
公平锁与非公平锁唯一的区别在于:非公平锁不会判断等待队列中是否有节点在等待获取锁,而是直接尝试获取锁;获取不到再把当前线程节点添加进等待队列尾部,并判断是否挂起。
4.3 lock() 加锁流程

4.4 unlock() 释放锁

释放流程:先判断持有锁的线程是否为当前线程,不是则抛异常;是则将 state 减 1,减到 0 表示彻底释放,唤醒等待队列中的挂起线程节点。
4.5 非公平锁执行流程

4.6 Condition 详解
Condition 是一个接口,提供线程之间的协调机制,可以看作更灵活、更强大的 wait() 和 notify() 机制,通常与 Lock 接口(如 ReentrantLock)一起使用。核心作用体现在两方面:
- 等待/通知机制:允许线程等待某个条件成立,或通知其他线程条件已满足,类似 Object 的 wait()/notify(),但更灵活。
- 多条件协调:一个 Lock 可以对应多个 Condition 对象,可为不同等待条件创建不同 Condition,实现对多个等待线程集合的独立控制。
调用 Condition.await() 使线程等待,其他线程调用 Condition.signal() 或 signalAll() 唤醒等待线程。注意:调用 await() 和 signal() 都必须在 lock 保护之内。
| 方法 | 说明 |
|---|---|
void await() |
使当前线程等待,直到被 signal()/signalAll() 唤醒、被中断或假唤醒;等待前释放锁,唤醒后重新尝试获取锁 |
boolean await(long time, TimeUnit unit) |
等待指定时间,超时未被唤醒则返回;等待前释放锁,唤醒或超时后重新获取锁 |
void signal() |
唤醒在此 Condition 上等待的一个线程,被唤醒线程从 await() 返回并重新尝试获取锁 |
void signalAll() |
唤醒在此 Condition 上等待的所有线程 |
实战:ReentrantLock + Condition 实现生产者消费者
java
public class ReentrantLockDemo3 {
public static void main(String[] args) {
Queue queue = new Queue(5);
new Thread(new Producer(queue)).start();
new Thread(new Customer(queue)).start();
}
}
/**
队列封装类
*/
class Queue {
private Object[] items;
int size = 0;
int takeIndex;
int putIndex;
private ReentrantLock lock;
public Condition notEmpty; // 消费者阻塞唤醒条件:队列为空阻塞,生产者生产完唤醒
public Condition notFull; // 生产者阻塞唤醒条件:队列满了阻塞,消费者消费完唤醒
public Queue(int capacity) {
this.items = new Object[capacity];
lock = new ReentrantLock();
notEmpty = lock.newCondition();
notFull = lock.newCondition();
}
public void put(Object value) throws Exception {
lock.lock();
try {
while (size == items.length) {
// 队列满了让生产者等待
notFull.await();
}
items[putIndex] = value;
if (++putIndex == items.length) {
putIndex = 0;
}
size++;
notEmpty.signal(); // 生产完唤醒消费者
} finally {
System.out.println("producer 生产:" + value);
lock.unlock();
}
}
public Object take() throws Exception {
lock.lock();
try {
// 队列空了就让消费者等待
while (size == 0) {
notEmpty.await();
}
Object value = items[takeIndex];
items[takeIndex] = null;
if (++takeIndex == items.length) {
takeIndex = 0;
}
size--;
notFull.signal(); // 消费完唤醒生产者生产
return value;
} finally {
lock.unlock();
}
}
}
要点:使用 while 而非 if 判断条件,防止假唤醒;两个 Condition 分别控制"队列满"和"队列空",实现精准唤醒。
应用场景
- 解决多线程竞争资源的问题,例如多个线程同时对同一个数据库进行写操作,可用 ReentrantLock 保证每次只有一个线程写入。
- 实现多线程任务的顺序执行,例如一个线程执行完某个任务后,再让另一个线程执行任务。
- 实现多线程等待/通知机制,例如某个线程执行完某个任务后,通知其他线程继续执行任务。
并发同步工具类应用场景:https://www.processon.com/view/link/6620b9d763dc8148f6486eda
五、总结
- 管程是设计思想:把共享变量和操作封装起来,同时解决互斥与同步;MESA 模型是当前主流,被唤醒后需重新竞争锁并再次检查条件。
- AQS 是通用框架 :以
volatile int state表示资源状态,通过 CAS 修改,通过 CLH 双向队列管理阻塞线程,通过条件队列支持 await/signal。 - 模板方法模式:AQS 提供 acquire/release 骨架,子类实现 tryAcquire/tryRelease 等钩子方法。
- 公平与非公平的差异 :仅在于 state 为 0 时是否先检查
hasQueuedPredecessors();非公平锁吞吐更高,但可能造成线程饥饿。 - 可重入的实现:state 记录重入次数,同一线程再次获取时 state 加 1,释放时减 1,减到 0 才真正释放。
- 两种队列的转换:await 从同步队列转到条件队列,signal 从条件队列转回同步队列。
六、面试常见提问与解答
Q1:什么是管程?Java 中管程有哪两种实现?
答: 管程是管理共享变量及其操作过程、使其支持并发的一种同步机制,它同时封装了互斥和同步。历史上出现过 Hasen、Hoare、MESA 三种模型,目前广泛使用的是 MESA 模型。Java 中有两种实现:一是基于 Object 的 Monitor 机制,用于 synchronized 内置锁;二是抽象队列同步器 AQS,用于 JUC 包下的 Lock 锁机制。
Q2:MESA 模型有什么特点?为什么条件判断要用 while?
答: MESA 模型中,被 signal 唤醒的线程不会立即执行,而是从条件队列转移到同步队列,重新竞争锁,拿到锁后从 await 处继续执行。由于在等待期间条件可能已被其他线程改变,所以必须用 while 循环重新检查条件,而不能用 if 只判断一次。
Q3:AQS 的核心组成是什么?
答: AQS 的核心包括:① volatile int state 表示同步状态,通过 getState/setState/compareAndSetState 访问;② CLH 双向同步等待队列,存放获取锁失败的线程节点;③ 条件等待队列(单向链表,nextWaiter 连接),配合 Condition 使用;④ 独占/共享两种资源访问模式;⑤ 一组需要子类实现的模板方法 tryAcquire、tryRelease、tryAcquireShared、tryReleaseShared、isHeldExclusively。
Q4:AQS 中 Node 有哪几种状态?分别代表什么?
**答:**共 5 种:0 为初始化状态,表示在 sync 队列中等待获取锁;1(CANCELLED)表示线程被取消;-1(SIGNAL)表示后继节点需要被 unpark;-2(CONDITION)表示节点在 condition 队列中等待;-3(PROPAGATE)表示后续的 acquireShared 能够得以执行,用于解决共享锁唤醒传播问题。
Q5:同步队列和条件队列是如何转换的?
答: 线程调用 await() 时释放锁,并从同步队列转移到条件队列;其他线程调用 signal()/signalAll() 时,把条件队列中的节点转移到同步队列尾部,被转移的线程需要重新竞争锁才能继续执行。
Q6:如何基于 AQS 实现一把独占锁?
**答:**继承 AbstractQueuedSynchronizer,实现 tryAcquire 用 CAS 把 state 从 0 改为 1 并记录持有线程,实现 tryRelease 把 state 置 0 并清空持有线程;对外暴露 lock() 调用 acquire(1)、unlock() 调用 release(1)。加锁失败时的入队、挂起、唤醒全部由 AQS 完成,这就是模板方法模式的价值。
Q7:ReentrantLock 的公平锁和非公平锁有什么区别?
答: 区别只在 tryAcquire 中 state 为 0 时的处理:公平锁先调用 hasQueuedPredecessors() 判断是否有线程在排队,有则放弃抢锁,保证 FIFO;非公平锁直接 CAS 抢锁,抢不到再入队。非公平锁减少了线程唤醒开销,吞吐量更高,但可能导致排队线程饥饿;公平锁保证顺序但性能略低。ReentrantLock 默认是非公平锁。
Q8:ReentrantLock 是如何实现可重入的?
答: 通过 AQS 的 state 记录重入次数。线程首次获取锁时 state 由 0 变为 1;同一线程再次获取时,判断 current == getExclusiveOwnerThread() 成立,则 state 加 1;释放时 state 减 1,减到 0 才真正释放锁并唤醒后继节点。若重入次数溢出 int 最大值会抛出 Error("Maximum lock count exceeded")。
Q9:ReentrantLock 加锁失败后线程是如何被挂起的?
答: acquire 失败后调用 addWaiter 把线程封装为 EXCLUSIVE 节点加入 CLH 队列尾部(队列为空时先通过 enq 初始化头尾节点),然后进入 acquireQueued 自旋:若前驱是 head 就再尝试 tryAcquire,成功则把自己设为 head;否则调用 shouldParkAfterFailedAcquire 检查前驱状态,把前驱状态 CAS 改为 SIGNAL 后,通过 LockSupport.park() 挂起线程。
Q10:ReentrantLock 释放锁的流程是怎样的?
**答:**unlock 调用 AQS 的 release(1),进而调用 tryRelease:先校验当前线程是否为锁持有者,不是则抛 IllegalMonitorStateException;是则将 state 减 1,若减后为 0 则清空 exclusiveOwnerThread 并返回 true。release 拿到 true 后,若 head 不为空且 waitStatus 不为 0,调用 unparkSuccessor 唤醒后继节点。
Q11:synchronized 和 ReentrantLock 有什么区别?
| 对比项 | synchronized | ReentrantLock |
|---|---|---|
| 实现层面 | JVM 层面,基于 Object Monitor | JDK 层面,基于 AQS + CAS |
| 锁的释放 | 自动释放,异常也会释放 | 需在 finally 中手动 unlock |
| 公平性 | 非公平 | 可选公平或非公平 |
| 中断与超时 | 不支持 | 支持 lockInterruptibly、tryLock(timeout) |
| 条件变量 | 一个 wait/notify 队列 | 可创建多个 Condition |
Q12:Condition 和 Object 的 wait/notify 有什么区别?
参考回答:
- 绑定对象不同:wait/notify 绑定在 Object 上,一个对象只有一个等待队列;Condition 绑定在 Lock 上,一个 Lock 可以创建多个 Condition,实现多条件精准唤醒。
- 使用前提:wait/notify 必须在 synchronized 块中调用;Condition 的 await/signal 必须在 lock 保护范围内调用。
- 灵活性:Condition 支持超时等待、可中断等待,且能按条件分组唤醒,适合实现生产者消费者等复杂协作。
Q13:为什么 AQS 的 state 要用 volatile 修饰?
答: state 表示同步状态,会被多个线程并发读写。volatile 保证其可见性,使一个线程修改后其他线程能立即看到;同时配合 compareAndSetState 的 CAS 操作保证原子性,二者结合实现无锁的同步状态更新。
Q14:CLH 队列为什么把自旋改成了阻塞?
**答:**原始 CLH 队列中线程通过自旋等待前驱节点释放锁,在锁竞争激烈或持有时间较长时会持续消耗 CPU。Java 的实现改为阻塞机制:线程入队后通过 LockSupport.park 挂起,由前驱节点在释放锁时 unpark 唤醒,从而降低 CPU 开销。