深入理解AQS之ReentrantLock独占锁

一、概述

本文基于课程内容整理 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 分别控制"队列满"和"队列空",实现精准唤醒。

应用场景

  1. 解决多线程竞争资源的问题,例如多个线程同时对同一个数据库进行写操作,可用 ReentrantLock 保证每次只有一个线程写入。
  2. 实现多线程任务的顺序执行,例如一个线程执行完某个任务后,再让另一个线程执行任务。
  3. 实现多线程等待/通知机制,例如某个线程执行完某个任务后,通知其他线程继续执行任务。

并发同步工具类应用场景:https://www.processon.com/view/link/6620b9d763dc8148f6486eda

五、总结

  1. 管程是设计思想:把共享变量和操作封装起来,同时解决互斥与同步;MESA 模型是当前主流,被唤醒后需重新竞争锁并再次检查条件。
  2. AQS 是通用框架 :以 volatile int state 表示资源状态,通过 CAS 修改,通过 CLH 双向队列管理阻塞线程,通过条件队列支持 await/signal。
  3. 模板方法模式:AQS 提供 acquire/release 骨架,子类实现 tryAcquire/tryRelease 等钩子方法。
  4. 公平与非公平的差异 :仅在于 state 为 0 时是否先检查 hasQueuedPredecessors();非公平锁吞吐更高,但可能造成线程饥饿。
  5. 可重入的实现:state 记录重入次数,同一线程再次获取时 state 加 1,释放时减 1,减到 0 才真正释放。
  6. 两种队列的转换: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 开销。

相关推荐
better_liang6 个月前
每日Java面试场景题知识点之-JUC并发编程核心原理与实战
java·线程池·并发编程·juc·aqs·reentrantlock·concurrenthashmap
tongluowan0076 个月前
以ReentrantLock为例解释AQS的工作流程
java·模板方法模式·aqs·reentrantlock
恼书:-(空寄7 个月前
AQS原理+ReentrantLock源码+与synchronized深度对比
synchronized·aqs·reentrantlock
庞轩px8 个月前
AQS(AbstractQueuedSynchronizer)源码深度解析:从CLH队列到ReentrantLock实现
java·并发编程·juc·aqs·reentrantlock
庞轩px8 个月前
Synchronized 与 ReentrantLock 深度对比
并发编程·synchronized·aqs·锁·reentrantlock
better_liang10 个月前
每日Java面试场景题知识点之-JUC锁的底层原理
java·并发编程·juc·锁机制·reentrantlock·readwritelock·底层原理
C雨后彩虹10 个月前
ReentrantLock 源码解析:AQS 核心原理
java·reentrantlock·lock
C雨后彩虹10 个月前
ReentrantLock入门:核心特性与基本使用
java·数据结构·reentrantlock·lock
Chen不旧10 个月前
java基于reentrantlock/condition/queue实现阻塞队列
java·开发语言·signal·reentrantlock·await·condition