java中AQS-ConditionObject的用法

# Java中AQS-ConditionObject的用法

## 一、AQS与ConditionObject概述

Java并发包中的`AbstractQueuedSynchronizer`（AQS）是构建锁和同步器的基础框架，而`ConditionObject`是AQS的内部类，用于实现条件等待/通知机制。它相当于传统监视器模型的`wait/notify`的增强版，提供了更灵活、更可控的线程协作方式。

### 核心特点
- **多条件队列**：单个AQS可关联多个ConditionObject
- **精确唤醒**：支持唤醒指定条件的线程（signal()）
- **可中断等待**：提供可中断/不可中断的等待选项
- **超时控制**：支持纳秒级超时设置

## 二、ConditionObject核心方法解析

### 1. 等待方法
```java
// 不可中断等待
void await() throws InterruptedException;

// 可中断等待
void awaitUninterruptibly();

// 带超时的等待（纳秒精度）
long awaitNanos(long nanosTimeout) throws InterruptedException;
boolean await(long time, TimeUnit unit) throws InterruptedException;

2. 通知方法

// 唤醒一个等待线程
void signal();

// 唤醒所有等待线程
void signalAll();

三、典型使用场景

场景1：生产者-消费者模型

class BoundedBuffer {
    final Lock lock = new ReentrantLock();
    final Condition notFull = lock.newCondition();
    final Condition notEmpty = lock.newCondition();
    final Object[] items = new Object[100];
    int putptr, takeptr, count;

    public void put(Object x) throws InterruptedException {
        lock.lock();
        try {
            while (count == items.length)
                notFull.await();  // 等待不满条件
            items[putptr] = x;
            if (++putptr == items.length) putptr = 0;
            ++count;
            notEmpty.signal();    // 唤醒消费者
        } finally {
            lock.unlock();
        }
    }

    public Object take() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0)
                notEmpty.await(); // 等待不空条件
            Object x = items[takeptr];
            if (++takeptr == items.length) takeptr = 0;
            --count;
            notFull.signal();    // 唤醒生产者
            return x;
        } finally {
            lock.unlock();
        }
    }
}

场景2：线程交替执行

class AlternatingPrinter {
    private final Lock lock = new ReentrantLock();
    private final Condition conditionA = lock.newCondition();
    private final Condition conditionB = lock.newCondition();
    private boolean flag = true;

    public void printA() {
        lock.lock();
        try {
            while (!flag) {
                conditionA.await();
            }
            System.out.println("A");
            flag = false;
            conditionB.signal();
        } finally {
            lock.unlock();
        }
    }

    public void printB() {
        lock.lock();
        try {
            while (flag) {
                conditionB.await();
            }
            System.out.println("B");
            flag = true;
            conditionA.signal();
        } finally {
            lock.unlock();
        }
    }
}

四、实现原理深度解析

1. 等待队列结构

• 每个ConditionObject维护独立的条件队列
• 节点使用AQS的Node类，状态为CONDITION(-2)
• 队列采用FIFO结构，但实际唤醒顺序取决于实现

2. await()执行流程

1. 创建新节点加入条件队列
2. 完全释放持有的锁
3. 阻塞当前线程
4. 被唤醒后重新竞争锁
5. 从条件队列转移到同步队列

graph TD
    A[调用await] --> B[加入条件队列]
    B --> C[释放锁]
    C --> D[进入阻塞状态]
    D -->|被signal| E[转移到同步队列]
    E --> F[竞争锁资源]

3. signal()执行流程

1. 将条件队列的首节点转移到同步队列
2. 修改节点状态从CONDITION到0
3. 唤醒节点对应的线程

五、最佳实践与注意事项

1. 使用规范

• 必须在lock()和unlock()之间调用await/signal
• 判断条件必须使用while循环（防止虚假唤醒）

while (conditionNotMet) {
    cond.await();
}

2. 性能优化

• 优先使用signal()而非signalAll()
• 对不同的等待条件使用不同的Condition实例
• 考虑使用awaitNanos()替代await()减少响应延迟

3. 常见陷阱

• 死锁风险：未正确配对lock/unlock
• 丢失唤醒：先signal后await
• 长时间阻塞：未设置合理的超时时间

六、与Object监视器对比

七、总结

ConditionObject作为AQS的条件等待实现，提供了比传统wait/notify更强大的线程协作能力。其核心价值在于： 1. 通过分离条件队列实现更精细的线程控制 2. 支持中断和超时等现代并发需求 3. 与Lock接口完美配合形成完整的并发工具链

正确理解和使用ConditionObject可以显著提升复杂并发场景下的代码可维护性和系统吞吐量。建议结合具体业务场景，合理设计条件谓词和通知策略，以充分发挥其并发控制优势。 “`

注：本文实际约1500字，可根据需要增减示例或原理分析部分调整字数。关键代码示例已包含核心用法，原理部分可通过添加更多实现细节扩充。