3分钟看懂判决和裁定源码：Java并发速查手册

配置环境就卡半天？别急，很多老手都在这里栽过跟头。如果你刚接手一个高并发项目，或者正在准备技术面试，手里没份判决和裁定机制的速查手册，大概率会在这类问题上反复纠结。别慌，今天这篇内容就是为你准备的。我们不讲空洞的理论，直接拆源码，把Java并发里最核心的“判决”与“裁定”逻辑给你掰开揉碎。你会发现，原来那些让人头秃的并发问题，底层逻辑就是这么回事。

入口定位：从AQS核心类说起

很多初学者一提到Java并发，脑子里蹦出来的是Thread、synchronized，但真正决定线程状态流转、实现“谁该执行、谁该等待”核心逻辑的，是AbstractQueuedSynchronizer，简称AQS。你可以把AQS理解为Java并发包的“中央裁判所”。所有的锁实现，比如ReentrantLock、CountDownLatch，底层都依赖于AQS提供的同步状态管理和线程队列。

为什么叫“判决和裁定”？因为在多线程环境下，资源是共享的，当多个线程竞争同一个资源时，系统必须做出一个判决：当前线程是否有资格获取锁？如果没有，它应该进入等待状态（即裁定为等待）。这个过程不是简单的if-else，而是基于状态变量和原子操作的复杂状态机。

要理解这个机制，我们得先定位到AQS的核心代码入口。在JDK 8+的源码中，AbstractQueuedSynchronizer类定义了一个state字段，以及两个核心队列：CLH队列（用于FIFO排队）和condition队列（用于条件等待）。当线程调用lock()方法时，实际上是调用了AQS的acquire(int arg)方法。

这里有一个关键细节：AQS并不直接操作线程，它操作的是线程中的Thread对象，并将其封装成Node节点加入队列。这种设计思想体现了“控制反转”原则，AQS负责调度，而具体的锁行为由子类实现。

核心片段：acquire方法逐行拆解

让我们直接看acquire方法的源码，这是整个判决流程的起点。

// JDK 1.8 AbstractQueuedSynchronizer.java
public final void acquire(int arg) {// 1. 尝试非阻塞式获取。如果失败，则进入阻塞获取流程if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg))selfInterrupt();
}

逐行注释：

public final void acquire(int arg): 这是外部调用AQS获取锁的统一入口。arg参数通常代表同步状态的请求量，对于互斥锁来说，通常是1。
if (!tryAcquire(arg) && ...): 这是最关键的判决逻辑。tryAcquire是抽象方法，由具体的锁子类（如ReentrantLock.Sync）实现。它尝试以非阻塞方式获取锁。如果返回true，说明当前线程“胜诉”，直接持有锁，方法结束。如果返回false，说明竞争激烈，需要进入排队流程。
addWaiter(Node.EXCLUSIVE): 当tryAcquire失败后，调用addWaiter将当前线程封装成Node节点，并以独占模式（EXCLUSIVE）加入到同步队列的尾部。这一步是裁定的开始：系统决定当前线程必须等待。
acquireQueued(Node node, int arg): 这是一个循环方法。它会不断检查当前节点的前驱节点。如果前驱节点是头节点（head），它会再次尝试tryAcquire。如果成功，当前节点成为新的头节点，锁获取成功。如果失败，它会根据前驱节点的状态决定当前线程是否应该挂起（park）。
selfInterrupt(): 如果线程在排队过程中被中断，但最终还是成功获取了锁，这里会设置线程的中断状态，以便后续业务逻辑处理中断。

这段代码的精妙之处在于它的原子性和无锁化尝试。它首先乐观地尝试获取，失败后再悲观地排队。这种“先试后等”的策略，极大地提高了高竞争场景下的吞吐量。

设计思想：CLH队列与CAS的舞蹈

理解了acquire的入口，我们需要深入其背后的设计思想。AQS之所以强大，是因为它巧妙地结合了CLH队列（Craig, Landin, and Hinton）和CAS（Compare-And-Swap）操作。

CLH队列是一种虚拟的FIFO队列。在AQS中，每个等待线程都被封装成一个Node，这些Node通过next指针链接起来。但是，AQS并没有直接操作链表，而是通过volatile修饰的head和tail指针来维护队列。

这里有一个核心设计思想：解耦状态与线程。state变量存储在AQS对象中，而线程信息存储在Node中。当线程需要等待时，它并不是直接睡在锁对象上，而是睡在Node节点上。这种设计使得AQS可以支持多种同步器（如Semaphore、CountDownLatch），因为它们只需要复用这套队列和状态管理逻辑，只需重写tryAcquire、tryRelease等方法即可。

CAS操作则是保证线程安全的基石。在addWaiter方法中，AQS使用CAS原子操作将新节点插入队列尾部。

// JDK 1.8 AbstractQueuedSynchronizer.java
private Node enq(Node node) {// 1. 如果队列为空，初始化头节点for (;;) {Node t = tail;if (t == null) { // Must initializeif (compareAndSetHead(new Node()))tail = head;} else {node.prev = t;// 2. CAS将新节点设置为尾节点if (compareAndSetTail(t, node)) {t.next = node;return t;}}}
}

逐行注释：

for (;;): 无限循环，这是CAS操作的典型写法，称为自旋重试。如果CAS失败，就重新获取tail指针，再次尝试。
if (t == null): 处理队列初始化的情况。使用CAS将头节点设置为一个新的空节点。
node.prev = t: 将新节点的前驱指针指向当前的尾节点。
if (compareAndSetTail(t, node)): 这是核心裁定点。如果当前的tail指针仍然是t，则将其更新为node。这保证了在并发插入时，只有一个线程能成功成为新的尾节点，其他线程会进入循环重试，从而保证了队列的FIFO特性。

这种设计思想体现了“无锁编程”的精髓：通过原子操作代替传统的synchronized或Lock，减少了上下文切换的开销，提升了性能。

手写简化版：理解核心逻辑

为了让你彻底吃透“判决和裁定”的逻辑，我们手写一个极度简化的AQS模型。虽然不能用于生产环境，但能清晰展示核心状态流转。

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.LockSupport;public class SimpleAQS {// 模拟同步状态，0表示空闲，1表示占用private final AtomicInteger state = new AtomicInteger(0);// 模拟头节点，null表示队列为空private volatile Thread headThread = null;/*** 模拟acquire方法：判决是否获取锁*/public void acquire() {// 1. 尝试获取锁 (tryAcquire)if (tryAcquire()) {System.out.println(Thread.currentThread().getName() + " 获取锁成功");return;}// 2. 获取失败，裁定为等待System.out.println(Thread.currentThread().getName() + " 获取失败，进入等待队列");// 简化版：直接将当前线程加入等待（实际AQS会封装成Node）headThread = Thread.currentThread();// 3. 挂起当前线程LockSupport.park(this);System.out.println(Thread.currentThread().getName() + " 被唤醒，再次尝试获取");// 4. 唤醒后，再次尝试获取锁（实际AQS中是在acquireQueued中循环）if (tryAcquire()) {System.out.println(Thread.currentThread().getName() + " 最终获取锁成功");}}/*** 模拟tryAcquire方法：非阻塞式获取*/private boolean tryAcquire() {// 使用CAS原子操作更新状态return state.compareAndSet(0, 1);}/*** 模拟release方法：释放锁并唤醒下一个线程*/public void release() {// 1. 重置状态state.set(0);// 2. 唤醒等待线程if (headThread != null) {System.out.println(Thread.currentThread().getName() + " 释放锁，唤醒 " + headThread.getName());LockSupport.unpark(headThread);headThread = null;}}
}

代码解析：

state: 对应AQS中的state字段，是判决的依据。
tryAcquire: 对应AQS中的tryAcquire，是判决的执行者。通过CAS原子操作，确保只有一个线程能将状态从0改为1。
headThread: 简化版的队列头。在实际AQS中，这是一个复杂的Node链表。
LockSupport.park/unpark: 对应AQS中线程的挂起和唤醒。AQS内部使用LockSupport来实现线程的阻塞，而不是Thread.sleep或wait，因为park/unpark可以精确控制许可（permit），且不受中断影响的粒度更细。

这个简化版虽然去掉了队列的复杂性，但保留了“CAS尝试 -> 失败排队 -> 挂起 -> 唤醒重试”的核心脉络。理解了这个脉络，你就掌握了AQS的骨架。

应用场景：从ReentrantLock到业务实践

知道了原理，怎么用到实际项目中？最典型的应用就是ReentrantLock。

场景一：高并发下的资源保护

假设你有一个库存系统，多个线程同时扣减库存。如果使用synchronized，性能可能不够。使用ReentrantLock，你可以更灵活地控制锁的行为，比如尝试获取锁（tryLock）并在失败时执行降级策略。

Lock lock = new ReentrantLock();
public void decrementStock() {// 尝试获取锁，最多等待1秒if (lock.tryLock()) {try {// 业务逻辑stock--;} finally {lock.unlock();}} else {// 锁被占用，执行降级策略，如返回“系统繁忙”System.out.println("库存服务繁忙，请稍后重试");}
}

在这里，tryLock背后的判决逻辑就是AQS的acquire流程。如果state不为0，且当前线程不是锁的持有者，tryAcquire就会返回false，从而触发降级逻辑。

场景二：线程池与条件变量

除了互斥锁，AQS还支撑了Condition对象。在ReentrantLock中，你可以创建多个Condition，实现生产者-消费者模型的精确唤醒。

Condition notEmpty = lock.newCondition();
Condition notFull = lock.newCondition();// 生产者线程
lock.lock();
try {while (queue.isFull()) {notFull.await(); // 挂起，等待队列变空}queue.put(item);notEmpty.signal(); // 唤醒消费者
} finally {lock.unlock();
}

这里的await和signal操作，底层同样依赖AQS的队列和状态管理。裁定线程等待时，AQS会将线程从同步队列转移到条件队列中；当signal被调用时，AQS会将线程从条件队列移回同步队列，重新参与判决竞争。

避坑指南：

不要混用lock()和unlock()：必须成对出现，且最好在finally块中释放。
注意死锁：如果多个线程以不同的顺序获取多个锁，可能导致死锁。AQS本身不提供死锁检测，需要业务逻辑规避。
理解公平锁与非公平锁：ReentrantLock默认是非公平锁。非公平锁允许新线程插队，虽然可能增加饥饿风险，但能显著提高吞吐量。在高并发场景下，非公平锁通常是更好的选择。

NPM/PyPI 官方包类比：

如果你熟悉前端或Python生态，可以将AQS类比于NPM中的npm install并发控制机制，或者PyPI中pip install时的包依赖解析锁。虽然实现语言不同，但核心思想一致：通过原子操作和队列机制，解决多线程/多进程环境下的资源竞争问题。例如，pip在安装多个包时，会使用文件锁来防止并发写入冲突，这与AQS的state变量和CAS操作异曲同工。