从ReentrantLock到AQS：深入解析Java并发锁的实现哲学

亲爱的非洲野猪2026-01-10 12:51

引言：为什么我们需要深入理解锁机制？

在Java并发编程的世界中，锁是协调多线程访问共享资源的核心机制。从早期的synchronized关键字到java.util.concurrent包中的各种高级锁，Java的并发工具一直在演进。本文将选择ReentrantLock作为切入点，深入分析其底层依赖的抽象队列同步器（AQS），揭示现代Java并发锁的设计哲学与实现原理。

第一部分：ReentrantLock的使用与特性

1.1 基础使用示例

java 复制代码 
public class ReentrantLockDemo {
    private final ReentrantLock lock = new ReentrantLock();
    private int counter = 0;
    
    public void increment() {
        lock.lock();  // 获取锁
        try {
            counter++;
            System.out.println("Counter: " + counter + " Thread: " + 
                             Thread.currentThread().getName());
        } finally {
            lock.unlock();  // 释放锁
        }
    }
    
    // 尝试获取锁，带有超时机制
    public boolean tryIncrement(long timeout, TimeUnit unit) {
        try {
            if (lock.tryLock(timeout, unit)) {
                try {
                    counter++;
                    return true;
                } finally {
                    lock.unlock();
                }
            }
            return false;
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        }
    }
}

1.2 ReentrantLock的核心特性

  1. 可重入性：同一个线程可以多次获得同一把锁
  2. 公平性选择：支持公平锁和非公平锁两种模式
  3. 可中断的锁获取：支持在等待锁的过程中响应中断
  4. 超时机制：可以尝试在指定时间内获取锁
  5. 条件变量支持：可以创建多个Condition对象

第二部分：揭开AQS的神秘面纱

2.1 AQS的设计思想

AQS采用模板方法模式 ，将同步器的核心算法框架固定，而将一些具体操作留给子类实现。其核心是一个FIFO双向队列 （CLH队列的变体）和一个表示同步状态的volatile变量。

java 复制代码 
// AQS简化版核心结构
public abstract class AbstractQueuedSynchronizer {
    // 同步状态，子类通过CAS操作修改
    private volatile int state;
    
    // 等待队列的头节点和尾节点
    private transient volatile Node head;
    private transient volatile Node tail;
    
    // 内部Node类定义
    static final class Node {
        volatile int waitStatus;  // 等待状态
        volatile Node prev;       // 前驱节点
        volatile Node next;       // 后继节点
        volatile Thread thread;   // 等待线程
        Node nextWaiter;          // 条件队列的后继节点
    }
}

2.2 同步状态（State）的妙用

AQS中的state字段是一个int类型的volatile变量，不同的同步器以不同的方式解释这个状态：

  • ReentrantLock：state表示持有锁的线程的重入次数
  • Semaphore：state表示当前可用的许可证数量
  • CountDownLatch：state表示还需要等待的事件数量
  • ReentrantReadWriteLock：高16位表示读锁数量，低16位表示写锁重入次数

第三部分：ReentrantLock如何基于AQS实现

3.1 公平锁与非公平锁的实现差异

java 复制代码 
// 非公平锁的实现
static final class NonfairSync extends Sync {
    final void lock() {
        // 直接尝试获取锁，不检查队列
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);  // 调用AQS的acquire方法
    }
    
    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

// 公平锁的实现
static final class FairSync extends Sync {
    final void lock() {
        acquire(1);  // 直接进入队列排队
    }
    
    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;
            }
        }
        // 重入逻辑...
        return false;
    }
}

3.2 锁获取的完整流程

java 复制代码 
// AQS中的acquire方法
public final void acquire(int arg) {
    if (!tryAcquire(arg) &&  // 步骤1：尝试获取锁
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))  // 步骤2&3：入队并等待
        selfInterrupt();  // 步骤4：恢复中断状态
}

// 节点入队
private Node addWaiter(Node mode) {
    Node node = new Node(Thread.currentThread(), mode);
    // 快速入队：尝试直接添加到队尾
    Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    enq(node);  // 完整入队流程
    return node;
}

// 在队列中等待获取锁
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            final Node p = node.predecessor();
            // 只有前驱节点是头节点时，才尝试获取锁
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            // 检查并更新等待状态，可能需要阻塞
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

第四部分：条件变量（Condition）的实现原理

4.1 ConditionObject的内部结构

java 复制代码 
public class ConditionObject implements Condition {
    private transient Node firstWaiter;   // 条件队列头节点
    private transient Node lastWaiter;    // 条件队列尾节点
    
    // 等待条件
    public final void await() throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        Node node = addConditionWaiter();  // 添加到条件队列
        int savedState = fullyRelease(node);  // 完全释放锁
        int interruptMode = 0;
        while (!isOnSyncQueue(node)) {
            LockSupport.park(this);  // 阻塞当前线程
            if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                break;
        }
        // 被唤醒后重新获取锁
        if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
            interruptMode = REINTERRUPT;
        if (node.nextWaiter != null)
            unlinkCancelledWaiters();
        if (interruptMode != 0)
            reportInterruptAfterWait(interruptMode);
    }
    
    // 发出信号
    public final void signal() {
        if (!isHeldExclusively())
            throw new IllegalMonitorStateException();
        Node first = firstWaiter;
        if (first != null)
            doSignal(first);  // 将节点从条件队列转移到同步队列
    }
}

4.2 条件队列与同步队列的交互

复制代码 
同步队列（获取锁的等待队列）     条件队列（等待条件的队列）
        head                       firstWaiter
          |                             |
        Node1 <-> Node2 <-> Node3       CNode1 -> CNode2 -> CNode3
          |                             |
        tail                       lastWaiter

signal()操作：
1. 将CNode1从条件队列移除
2. 将CNode1转移到同步队列尾部
3. 唤醒CNode1中的线程

第五部分：性能优化与最佳实践

5.1 锁优化策略

  1. 减少锁的持有时间：只在必要的时候持有锁
  2. 减小锁的粒度：使用更细粒度的锁
  3. 锁分离技术：如ReadWriteLock分离读锁和写锁
  4. 无锁编程：考虑使用CAS操作或并发容器

5.2 选择合适的锁策略

java 复制代码 
public class LockStrategyExample {
    // 场景1：高竞争环境下的公平性选择
    // 公平锁：保证顺序性，但吞吐量较低
    private final ReentrantLock fairLock = new ReentrantLock(true);
    
    // 场景2：低竞争或追求最大吞吐量
    // 非公平锁：可能产生饥饿，但吞吐量高
    private final ReentrantLock unfairLock = new ReentrantLock(false);
    
    // 场景3：读多写少的场景
    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    
    public void readOperation() {
        rwLock.readLock().lock();
        try {
            // 读操作，可以并发执行
        } finally {
            rwLock.readLock().unlock();
        }
    }
    
    public void writeOperation() {
        rwLock.writeLock().lock();
        try {
            // 写操作，独占执行
        } finally {
            rwLock.writeLock().unlock();
        }
    }
}

5.3 诊断锁问题

java 复制代码 
// 使用ThreadMXBean诊断死锁
public class DeadlockDetector {
    public static void detectDeadlock() {
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        long[] threadIds = threadMXBean.findDeadlockedThreads();
        if (threadIds != null) {
            ThreadInfo[] threadInfos = threadMXBean.getThreadInfo(threadIds);
            for (ThreadInfo threadInfo : threadInfos) {
                System.out.println("Deadlocked thread: " + threadInfo.getThreadName());
                System.out.println("Lock held: " + threadInfo.getLockName());
                System.out.println("Lock owner: " + threadInfo.getLockOwnerName());
            }
        }
    }
}

第六部分：AQS在Java并发框架中的应用

6.1 基于AQS的同步器家族

同步器类 状态state的含义 使用场景
ReentrantLock 重入次数 互斥访问
Semaphore 可用许可数 资源池限制
CountDownLatch 剩余计数 多任务等待
CyclicBarrier 等待线程数 线程屏障
ReentrantReadWriteLock 读写状态 读写分离

6.2 自定义同步器示例

java 复制代码 
// 基于AQS实现一个简单的二元闭锁
public class BinaryLatch {
    private static class Sync extends AbstractQueuedSynchronizer {
        protected int tryAcquireShared(int acquires) {
            // 闭锁打开时返回1，否则返回-1
            return getState() == 1 ? 1 : -1;
        }
        
        protected boolean tryReleaseShared(int releases) {
            // 打开闭锁
            setState(1);
            return true;
        }
    }
    
    private final Sync sync = new Sync();
    
    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }
    
    public void open() {
        sync.releaseShared(1);
    }
}

结论：AQS的设计哲学与启示

通过深入分析ReentrantLock和AQS，我们可以得出以下结论：

  1. 模板方法模式的威力：AQS通过模板方法提供了同步器的框架，子类只需要实现少数几个关键方法。

  2. 队列管理的艺术：CLH队列变体的设计既保证了公平性，又通过前驱节点的状态传递减少了不必要的线程唤醒。

  3. 状态机的思维：AQS将线程的等待状态建模为节点的状态变迁，这是解决复杂同步问题的有效方法。

  4. 性能与公平的权衡：非公平锁通过"插队"机制提高吞吐量，公平锁通过严格排队保证顺序性。

  5. 可重入性的重要性：可重入锁避免了自死锁，简化了嵌套锁的使用。

理解AQS不仅有助于我们更好地使用Java并发工具，更重要的是，它提供了一种设计同步原语的通用范式。这种范式强调状态管理、队列操作和线程调度的分离，是现代并发编程的重要思想源泉。

扩展阅读

  1. Java Memory Model (JMM)：理解happens-before关系
  2. Lock-Free算法：比较锁与无锁编程的优劣
  3. Synchronized的优化：偏向锁、轻量级锁、重量级锁的升级过程
  4. StampedLock：Java 8引入的乐观读锁机制

通过从ReentrantLock到AQS的深入探索，我们不仅掌握了一个具体技术的实现细节，更重要的是理解了Java并发框架的设计哲学。这种从具体到抽象，再从抽象到具体的思考过程，是每一位Java开发者都应该掌握的工程思维方法。

相关推荐
sunywz17 小时前
【JVM】（4）JVM对象创建与内存分配机制深度剖析
开发语言·jvm·python
星火开发设计17 小时前
C++ set 全面解析与实战指南
开发语言·c++·学习·青少年编程·编程·set·知识
wheelmouse778817 小时前
如何设置VSCode打开文件Tab页签换行
java·python
yangminlei17 小时前
Spring Boot——日志介绍和配置
java·spring boot
廋到被风吹走17 小时前
【Spring】Spring Boot Starter设计：公司级监控SDK实战指南
java·spring boot·spring
码头整点薯条17 小时前
启动报错：Invalid value type for attribute ‘factoryBeanObjectType‘ 解决方案
java
沛沛老爹17 小时前
Web开发者进阶AI：Agent Skills-深度迭代处理架构——从递归函数到智能决策引擎
java·开发语言·人工智能·科技·架构·企业开发·发展趋势
工具罗某人17 小时前
docker快速部署kafka
java·nginx·docker
秋饼17 小时前
【手撕 @EnableAsync：揭秘 SpringBoot @Enable 注解的魔法开关】
java·spring boot·后端
热门推荐
01GitHub 镜像站点02Labelme从安装到标注：零基础完整指南03安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）04Linux下V2Ray安装配置指南05jdk21下载、安装（Windows、Linux、macOS）062025-04-03 Latex学习1——本地配置Latex + VScode环境07【踩坑笔记】50系显卡适配的 PyTorch 安装08Opencode CLI 安装成功,但是启动失败09UV安装并设置国内源10全球最强模型Grok4，国内已可免费使用！（附教程）