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 initialize
if (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操作异曲同工。
结语：你的实战经验
以上就是Java并发中“判决和裁定”机制的核心源码解析。从AQS的acquire入口，到CLH队列的CAS操作，再到ReentrantLock的业务应用，我们完整走了一遍。
这套机制是Java并发编程的基石。理解它，不仅能帮你解决高并发下的性能问题，还能让你在面对面试时从容不迫。
不过，理论终究是理论。在实际项目中，你肯定遇到过更复杂的场景，比如锁竞争过于激烈导致CPU飙升，或者条件变量使用不当导致线程泄漏。
你公司项目里是怎么处理这类高并发竞争问题的？有没有遇到过AQS相关的诡异Bug？欢迎在评论区分享你的实战经验和踩坑记录，咱们一起交流！ 
长河君 · 2026/9/22 0:28:18 · 阅读 1.2k 3分钟看懂判决和裁定源码：Java并发速查手册
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 initialize
if (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操作异曲同工。
结语：你的实战经验
以上就是Java并发中“判决和裁定”机制的核心源码解析。从AQS的acquire入口，到CLH队列的CAS操作，再到ReentrantLock的业务应用，我们完整走了一遍。
这套机制是Java并发编程的基石。理解它，不仅能帮你解决高并发下的性能问题，还能让你在面对面试时从容不迫。
不过，理论终究是理论。在实际项目中，你肯定遇到过更复杂的场景，比如锁竞争过于激烈导致CPU飙升，或者条件变量使用不当导致线程泄漏。
你公司项目里是怎么处理这类高并发竞争问题的？有没有遇到过AQS相关的诡异Bug？欢迎在评论区分享你的实战经验和踩坑记录，咱们一起交流！