企业官网建设流程全解析

一、引言

在并发编程中，锁与同步器是构建线程安全程序的基石。许多开发者能够熟练使用ReentrantLock或CountDownLatch，但当被问到“如何自己实现一个锁”时，往往停留在synchronized或wait/notify的简陋版本，难以在生产环境中胜任高并发场景。Doug Lea 大师设计的 AQS 框架，通过模板方法模式将同步状态管理、线程阻塞/唤醒、队列机制封装得淋漓尽致，使我们只需重写少量方法即可获得自定义同步器的强大能力。

本文将先拆解 AQS 的核心数据结构与算法，再分别从独占模式（如ReentrantLock）和共享模式（如Semaphore）两大维度深入源码，最后设计并实现一个比肩 JDK 性能的自定义互斥锁和共享锁，辅以 JMH 压测数据，让每一位读者都能真正从“会用”跨越到“精通”。

二、AQS 设计核心：状态与队列

AQS 的核心可以归纳为：

// 同步状态，volatile 保证可见性 private volatile int state; // CLH 变体队列的头部和尾部 private transient volatile Node head; private transient volatile Node tail;

• state：代表同步状态。ReentrantLock中state=0表示未锁定，state>0表示重入次数；Semaphore中state表示可用许可数。

• CLH 变体队列：一个先进先出（FIFO）的虚拟双向队列，用于存放获取同步状态失败的线程。每个线程被包装成Node节点，通过自旋 +LockSupport.park()实现高效阻塞。

Node关键字段：

static final class Node { volatile int waitStatus; // 状态：CANCELLED, SIGNAL, CONDITION, PROPAGATE volatile Node prev; volatile Node next; volatile Thread thread; Node nextWaiter; // 标记共享模式或独占模式 // 共享模式常量 static final Node SHARED = new Node(); static final Node EXCLUSIVE = null; }

waitStatus是精妙的设计：

• SIGNAL (-1)：后继节点需要被唤醒。

• CANCELLED (1)：线程超时或中断取消。

• CONDITION (-2)：节点在条件队列中等待。

• PROPAGATE (-3)：共享模式下，释放操作需传播到后续节点。

三、独占模式源码全景分析

以ReentrantLock的lock()为例，调用链进入 AQS 的acquire(int arg)。

3.1 acquire 模板方法

public final void acquire(int arg) { if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt(); }

步骤拆解：

1. tryAcquire：子类实现的一次快速获取尝试（非公平锁中直接CAS抢夺state）。

2. addWaiter：快速尝试失败后，将当前线程包装成独占节点并原子地加入等待队列尾部。

3. acquireQueued：节点进入队列后进入自旋+阻塞循环，等待前驱唤醒。

3.2 addWaiter：入队操作

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); // 自旋CAS入队 return node; } private Node enq(final Node node) { for (;;) { Node t = tail; if (t == null) { // 必须初始化 if (compareAndSetHead(new Node())) tail = head; } else { node.prev = t; if (compareAndSetTail(t, node)) { t.next = node; return t; } } } }

这里用了经典的双重检查 + 自旋CAS，保证高并发下队列的安全构建。

3.3 acquireQueued：自旋与阻塞

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

核心逻辑：

• 只有前驱是head的节点才有资格尝试获取锁，这样保证公平性（即使非公平锁也会在此处重新竞争）。

• shouldParkAfterFailedAcquire会将前驱的waitStatus改为 SIGNAL，保证后继安心阻塞。

• parkAndCheckInterrupt调用LockSupport.park(this)阻塞线程，返回中断状态（线程被中断时park会立即返回）。

3.4 release：唤醒后继

public final boolean release(int arg) { if (tryRelease(arg)) { Node h = head; if (h != null && h.waitStatus != 0) unparkSuccessor(h); return true; } return false; }

unparkSuccessor找到离 head 最近且未取消的后继节点，执行LockSupport.unpark(s.thread)唤醒阻塞的线程，被唤醒的线程会从parkAndCheckInterrupt返回，继续在acquireQueued中自旋抢夺锁。

四、共享模式源码全景分析

共享模式典型代表Semaphore，通过acquireShared和releaseShared实现。

4.1 acquireShared 模板方法

public final void acquireShared(int arg) { if (tryAcquireShared(arg) < 0) doAcquireShared(arg); }

tryAcquireShared由子类实现，返回剩余许可数，负数表示获取失败。

4.2 doAcquireShared

private void doAcquireShared(int arg) { final Node node = addWaiter(Node.SHARED); boolean failed = true; try { boolean interrupted = false; for (;;) { final Node p = node.predecessor(); if (p == head) { int r = tryAcquireShared(arg); if (r >= 0) { setHeadAndPropagate(node, r); p.next = null; if (interrupted) selfInterrupt(); failed = false; return; } } if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) interrupted = true; } } finally { if (failed) cancelAcquire(node); } }

与独占模式的最大差异：成功获取后调用setHeadAndPropagate，它会检查剩余许可数，若propagate > 0则唤醒后继的共享节点，形成“链式传播”，让批量共享锁申请者均能快速唤醒，极大提高并发吞吐量。

4.3 releaseShared

public final boolean releaseShared(int arg) { if (tryReleaseShared(arg)) { doReleaseShared(); return true; } return false; }

doReleaseShared核心就是一个for(;;)循环，CAS 修改 head 的waitStatus，并unparkSuccessor唤醒后继。因为共享模式下可能有多个线程同时释放，这里必须自旋确保唤醒传播。

五、实战：自定义同步器

理论需落地。我们将基于 AQS 构建两个同步器：Mutex（独占不可重入锁）和SharedLock（共享锁，类似信号量为1的Semaphore，但可扩展）。

5.1 自定义互斥锁 Mutex

import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.AbstractQueuedSynchronizer; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; public class Mutex implements Lock { private final Sync sync = new Sync(); private static class Sync extends AbstractQueuedSynchronizer { @Override protected boolean tryAcquire(int arg) { if (compareAndSetState(0, 1)) { setExclusiveOwnerThread(Thread.currentThread()); return true; } return false; } @Override protected boolean tryRelease(int arg) { if (getState() == 0) throw new IllegalMonitorStateException(); setExclusiveOwnerThread(null); setState(0); return true; } @Override protected boolean isHeldExclusively() { return getState() == 1; } Condition newCondition() { return new ConditionObject(); } } @Override public void lock() { sync.acquire(1); } @Override public void lockInterruptibly() throws InterruptedException { sync.acquireInterruptibly(1); } @Override public boolean tryLock() { return sync.tryAcquire(1); } @Override public boolean tryLock(long time, TimeUnit unit) throws InterruptedException { return sync.tryAcquireNanos(1, unit.toNanos(time)); } @Override public void unlock() { sync.release(1); } @Override public Condition newCondition() { return sync.newCondition(); } }

5.2 自定义共享锁 SharedLock

允许最多permits个线程同时持有：

import java.util.concurrent.locks.AbstractQueuedSynchronizer; public class SharedLock { private final Sync sync; public SharedLock(int permits) { sync = new Sync(permits); } private static class Sync extends AbstractQueuedSynchronizer { Sync(int permits) { setState(permits); } @Override protected int tryAcquireShared(int acquires) { for (;;) { int available = getState(); int remaining = available - acquires; if (remaining < 0 || compareAndSetState(available, remaining)) { return remaining; } } } @Override protected boolean tryReleaseShared(int releases) { for (;;) { int current = getState(); int next = current + releases; if (compareAndSetState(current, next)) { return true; } } } } public void lock() { sync.acquireShared(1); } public void unlock() { sync.releaseShared(1); } }

可以看到，依托 AQS，仅仅重写两个方法就实现了生产级同步器。

六、性能基准测试（JMH）

使用 JMH 对比自制的Mutex与ReentrantLock在重度竞争下的吞吐量。

测试代码：

@BenchmarkMode(Mode.Throughput) @OutputTimeUnit(TimeUnit.SECONDS) @State(Scope.Benchmark) @Fork(1) @Threads(8) public class LockBenchmark { private int counter; private final Mutex mutex = new Mutex(); private final ReentrantLock reentrantLock = new ReentrantLock(); @Benchmark public void testMutex() { mutex.lock(); try { for (int i = 0; i < 100; i++) counter++; } finally { mutex.unlock(); } } @Benchmark public void testReentrantLock() { reentrantLock.lock(); try { for (int i = 0; i < 100; i++) counter++; } finally { reentrantLock.unlock(); } } }

测试结果（ops/s，越高越好）：

自制的Mutex性能介于两者之间，主要因为其实现即为非公平模式，省略了ReentrantLock中的重入判断和一些额外检查，性能损失极小。而SharedLock与Semaphore(1)对比也表现接近。

这表明理解原理后“造轮子”的成本极低，且能针对业务特性深度定制。

七、高级技巧与避坑指南

1. 中断处理：自定义同步器若需支持中断，应重写tryAcquire时检查中断状态，并调用acquireInterruptibly。

2. 超时机制：利用doAcquireNanos实现限时等待，内部通过LockSupport.parkNanos精确控制。

3. 条件队列：AQS 内部的ConditionObject可以直接通过newCondition()暴露，实现await/signal，无需重复造轮子。

4. PROPAGATE 状态：共享模式下，doReleaseShared中若 head 状态为 PROPAGATE，必须继续传播，否则在高并发下会出现休眠线程无法唤醒的 BUG（Java 6 经典 bug 修复）。

5. 避免忙等待：务必通过shouldParkAfterFailedAcquire→parkAndCheckInterrupt路径阻塞线程，不要自行实现纯自旋锁，否则会拖垮 CPU。

八、总结

AQS 是 Java 并发编程的巅峰设计之一，其通过 CAS + 自旋 + 阻塞队列 的巧妙融合，平衡了性能与功能。掌握它的原理不仅能让你从容阅读j.u.c源码，更能赋予你“创造同步器”的能力，在特殊业务场景下写出比通用库更高效、更低内存的定制组件。

本文从设计、源码、实战、测试四个维度进行了全方位讲解，希望每一位读者都能亲手敲出属于自己的锁，体会 Doug Lea 大师作品中蕴含的优雅与力量。

原创不易，如果本文对你有所帮助，欢迎点赞、收藏，你的支持是我持续输出的最大动力！

参考资料：

• 《Java并发编程的艺术》

• JDK 11 AbstractQueuedSynchronizer 源码

• Doug Lea: “The java.util.concurrent Synchronizer Framework”

• 深入剖析Java并发基石：AQS实现原理与自定义同步器实战 - 摸鱼不慌