推荐订阅源

　　AQS（AbstractQueuedSynchronizer，抽象队列同步器） 是 Java 并发包（java.util.concurrent）的绝对核心。ReentrantLock、CountDownLatch、Semaphore、ReentrantReadWriteLock 等底层全部依赖 AQS

一、 核心思想：模板方法模式

• AQS 负责：维护同步状态（state）、管理线程的排队与阻塞、唤醒。

• 子类负责：定义什么是“获取锁成功”和“释放锁成功”（即如何操作 state）。

　　AQS 定义了几个关键方法，子类可以选择性重写（以下方法在 AQS 中默认抛出 UnsupportedOperationException，强制子类按需实现）：

tryAcquire(int)	独占模式获取锁（如 ReentrantLock）
tryRelease(int)	独占模式释放锁
tryAcquireShared(int)	共享模式获取锁（如 Semaphore、CountDownLatch）
tryReleaseShared(int)	共享模式释放锁
isHeldExclusively()	是否被当前线程独占

protected boolean isHeldExclusively() {
     throw new UnsupportedOperationException();
}

二、 核心结构

示例代码取自JDK21

1. volatile int state（同步状态）

    /**
     * The synchronization state.
     */
    private volatile int state;

　　不同的工具赋予它不同的含义：

• ReentrantLock：state = 0 表示无锁，state > 0 表示锁被重入次数。【独占模式】

final boolean tryLock() {
            Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (compareAndSetState(0, 1)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            } else if (getExclusiveOwnerThread() == current) {
                if (++c < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(c);
                return true;
            }
            return false;
        }

• Semaphore：state 表示可用许可数量。

• CountDownLatch：state 表示剩余计数。【共享模式】

/**
 * Synchronization control For CountDownLatch.
 * Uses AQS state to represent count.
 */

int getCount() {
            return getState();
        }

        protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -1;
        }

2. FIFO 双向队列

　　当线程获取锁失败时，会被包装成 Node 节点，加入队列尾部等待。

abstract static class Node {
        volatile Node prev;       // initially attached via casTail
        volatile Node next;       // visibly nonnull when signallable
        Thread waiter;            // visibly nonnull when enqueued
        volatile int status;      // written by owner, atomic bit ops by others

        // methods for atomic operations
        final boolean casPrev(Node c, Node v) {  // for cleanQueue
            return U.weakCompareAndSetReference(this, PREV, c, v);
        }
        final boolean casNext(Node c, Node v) {  // for cleanQueue
            return U.weakCompareAndSetReference(this, NEXT, c, v);
        }
        final int getAndUnsetStatus(int v) {     // for signalling
            return U.getAndBitwiseAndInt(this, STATUS, ~v);
        }
        final void setPrevRelaxed(Node p) {      // for off-queue assignment
            U.putReference(this, PREV, p);
        }
        final void setStatusRelaxed(int s) {     // for off-queue assignment
            U.putInt(this, STATUS, s);
        }
        final void clearStatus() {               // for reducing unneeded signals
            U.putIntOpaque(this, STATUS, 0);
        }

        private static final long STATUS
            = U.objectFieldOffset(Node.class, "status");
        private static final long NEXT
            = U.objectFieldOffset(Node.class, "next");
        private static final long PREV
            = U.objectFieldOffset(Node.class, "prev");
    }

View Code

　　JDK 21 AQS Node 的核心变化