Java并发之AQS详解的补充

同步器AQS中的等待队列与条件队列

本文首发于博客园：同步器AQS中的等待队列与条件队列
主要是为Java并发之AQS详解1.0的补充。

前提说明：

首先说明一点这里的等待队列，条件队列的意思。

AQS中的等待队列是指持有资源的等待队列，大家排队等着拿资源 (锁) 的。或者说是同步队列。

AQS中的条件队列就是本来我在等待队列等着拿资源的，但是一个Condition.await()被打入冷宫，从持有资源等待队列进入了没有资源的持有condition的等待队列。

了解了他俩的意思我们来看条件队列的具体。

在单纯地使用锁,比如ReentrantLock的时候，这个锁组件内部有一个继承同步器AQS的类，实现了其抽象方法，加锁、释放锁也只是涉及到AQS中的等待队列而已，也就是我们上一篇文章
Java并发之AQS详解1.0中的队列，那么条件队列又是什么呢？

---

当使用Condition的时候，条件队列的概念就出来了。Condition的获取一般都要与一个锁Lock相关，一个锁上面可以生产多个Condition。

Condition接口的主要实现类是AQS的内部类ConditionObject，每个Condition对象都包含一个条件队列。该队列是Condition对象实现等待/通知的关键。

我这里贴出一个来自Condition源码的例子，其功能实现和ArrayBlockingQueue相同。它维护了一个items数组。利用AQS的条件队列实现了当items数组满的时候使用Condition.await()将线程休眠，直到有人取出数组元素并Condition.signal()将线程唤醒。

大家可以好好看看。

/**这是一个来自Condition源码的例子
 * 假设我们有一个支持put和take方法的有界缓冲区。
 * 如果take空缓冲区上尝试获取，则线程将阻塞，直到项目变得可用；
 * 如果在一个完整的缓冲区上尝试put ，则线程将阻塞，直到有空间可用。
 * 我们希望继续等待put线程并在单独的等待集中take线程，
 * 以便我们可以使用在缓冲区中可用的项目或空间时仅通知单个线程的优化。
 * 这可以使用两个Condition实例来实现
 *
 *（ java.util.concurrent.ArrayBlockingQueue类提供了这个功能，
 * 所以没有理由实现这个示例使用类。）
 * @author zry
 * @create 2022-02-01 15:45
 */
public class BoundedBuffer {
    final Lock lock = new ReentrantLock();
    final Condition notFull = lock.newCondition();
    final Condition notEmpty = lock.newCondition();

    final Object[] items = new Object[10];
    int putptr, takeptr, count;

    public void put(Object x) throws InterruptedException {
        lock.lock();
        try {
            while (count == items.length) { //while循环防止发生“虚假唤醒”
                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();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        BoundedBuffer boundedBuffer = new BoundedBuffer();
        for (int i = 0; i < 9; i++) {
            boundedBuffer.put("红楼梦"+i);
        }
        for (int i = 0; i < 10; i++) {
            Object take = boundedBuffer.take();
            System.out.println("take = " + take);
        }

    }
}

在ReentranLock的newConditon方法中其实是创建了一个AbstractQueuedSynchronizer.ConditionObject对象：

Condition作为AQS的内部类，复用了AQS的结点，维护一个条件队列，队列初始时的结构如下：

AQS中同步队列与等待队列的关系如下:

AQS拥有一个同步队列和多个等待队列。

等待

调用condition的await方法，将会使当前线程进入等待队列并释放锁(先加入等待队列再释放锁)，同时线程状态转为等待状态。

从同步队列和阻塞队列的角度看，调用await方法时，相当于同步队列的首节点移到condition的等待队列中

看源码：

/**
实现可中断条件等待
*/
public final void await() throws InterruptedException {
	if (Thread.interrupted())//如果被中断了，就抛出 InterruptedException异常
		throw new InterruptedException();
	Node node = addConditionWaiter(); 
	int savedState = fullyRelease(node);//释放锁，{其中调用了release()方法将该线程的节点从之前的等待队列移除，详见AQS详解}，返回释放前的同步状态state
	int interruptMode = 0; //设置中断模式
	while (!isOnSyncQueue(node)) {
		LockSupport.park(this);
		if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
			break;
	}
	if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;//中断模式：重新中断
	if (node.nextWaiter != null) // clean up if cancelled
			unlinkCancelledWaiters();
	if (interruptMode != 0)
			reportInterruptAfterWait(interruptMode);
}

其中方法

addConditionWaiter()：

将当前线程添加到条件队列的队尾并返回该节点

fullyRelease(node) ：

释放锁，{其中调用了release()方法将该线程的节点从之前的等待队列移除，详见AQS详解}，返回释放前的同步状态state

acquireQueued(node, savedState)：

使线程阻塞在等待队列中获取资源，一直获取到资源后才返回。如果在整个等待过程中被中断过，则返回true，否则返回false。

总结一下

实现可中断条件等待。

1. 如果当前线程被中断，则抛出 InterruptedException。

2. 将节点添加到条件队列，使用保存状态savedState作为参数调用release，并将节点从等待队列中移除。

3. 保存getState返回的锁定状态。

4. 如果失败则抛出 IllegalMonitorStateException。

5. 阻塞直到发出信号或中断。

6. 通过以保存状态作为参数调用特定版本的acquire来重新获取。

7. 如果在步骤 5 中被阻塞时被中断，则抛出 InterruptedException。

通知

调用condition的signal方法时，将会把等待队列的首节点移到同步队列的尾部，然后唤醒该节点。
被唤醒，并不代表就会从await方法返回，也不代表该节点的线程能获取到锁，它一样需要加入到锁的竞争acquireQueued方法中去，只有成功竞争到锁，才能从await方法返回。就是换了个队列。

源码：

signal方法将等待时间最长的线程（如果存在）从该条件的等待队列就是我说的条件队列移动到拥有锁的等待队列。

/**将等待时间最长的线程（如果存在）从该条件的等待队列就是我说的条件队列移动到拥有锁的等待队列。
抛出：
IllegalMonitorStateException – 如果isHeldExclusively返回false
 */
public final void signal() {
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    Node first = firstWaiter;//获取条件队列第一个结点，老大
    if (first != null)
        doSignal(first); //将老大从条件队列删除并添加到等待队列中
}

OK，至此两篇文章，整个AQS的讲解全部完成。希望本文能够对学习Java并发编程的同学有所借鉴，中间写的有不对的地方，也欢迎讨论和指正~