Condition 的 await 方法

当调用condition.await()方法后会使当前获取锁的线程进入到等待队列，如果该线程能够从 await() 方法返回的话，一定是该线程获取了与 Condition 相关联的锁。
前面讲过了，Condition 只是一个接口，它的实现类为 ConditionObject，是 AQS 的子类。
ConditionObject 的 await 方法源码如下： 
public final void await() throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
	// 1. 将当前线程包装成Node，尾插入到等待队列中
    Node node = addConditionWaiter();
	// 2. 释放当前线程所占用的lock，在释放的过程中会唤醒同步队列中的下一个节点
    int savedState = fullyRelease(node);
    int interruptMode = 0;
    while (!isOnSyncQueue(node)) {
		// 3. 当前线程进入到等待状态
        LockSupport.park(this);
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
            break;
    }
	// 4. 自旋等待获取到同步状态（即获取到lock）
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
        interruptMode = REINTERRUPT;
    if (node.nextWaiter != null) // clean up if cancelled
        unlinkCancelledWaiters();
	// 5. 处理被中断的情况
    if (interruptMode != 0)
        reportInterruptAfterWait(interruptMode);
}
代码的主要逻辑请看注释。当前线程调用condition.await()方法后，会释放 lock 然后加入到等待队列，直到被 signal/signalAll 方法唤醒。
怎样将当前线程添加到等待队列？
调用 addConditionWaiter 方法会将当前线程添加到等待队列中，源码如下： 
private Node addConditionWaiter() {
 Node t = lastWaiter;
 if (t != null && t.waitStatus != Node.CONDITION) {
  //将不处于等待状态的节点从等待队列中移除
  unlinkCancelledWaiters();
  t = lastWaiter;
 }
 Node node = new Node(Thread.currentThread(), Node.CONDITION);
 //尾节点为空
 if (t == null)
        //将首节点指向node
  firstWaiter = node;
 else
  //将尾节点的nextWaiter指向node节点
  t.nextWaiter = node;
 //尾节点指向node
 lastWaiter = node;
 return node;
}
首先将 t 指向尾节点，如果尾节点不为空并且它的waitStatus!=-2（-2 为 CONDITION，表示正在等待 Condition 条件），则将不处于等待状态的节点从等待队列中移除，并且将 t 指向新的尾节点。然后将当前线程封装成 waitStatus 为-2 的节点追加到等待队列尾部。如果尾节点为空，则表明队列为空，将首尾节点都指向当前节点。
如果尾节点不为空，表明队列中有其他节点，则将当前尾节点的 nextWaiter 指向当前节点，将当前节点置为尾节点。
简单总结一下，这段代码的作用就是通过尾插入的方式将当前线程封装的 Node 插入到等待队列中，同时可以看出，Condtion 的等待队列是一个不带头节点的链式队列，不带头节点是指在链表数据结构中，链表的第一个节点就是实际存储的第一个数据元素，而不是一个特定的"头"节点，该节点不包含实际的数据。
1）不带头节点的链表：
  • 链表的第一个节点就是第一个实际的数据节点。
  • 当链表为空时，头引用（通常称为 head）指向 null。
2）带头节点的链表：
  • 链表有一个特殊的节点作为链表的开头，这个特殊的节点称为头节点。
  • 头节点通常不存储任何实际数据，或者它的数据字段不被使用。
  • 无论链表是否为空，头节点总是存在的。当链表为空时，头节点的下一个节点指向 null。
  • 使用头节点可以简化某些链表操作，因为不必特殊处理第一个元素的插入和删除。
1）不带头节点的链表 
public class Node {
    public int data;
    public Node next;

    public Node(int data) {
        this.data = data;
        this.next = null;
    }
}

public class LinkedListWithoutHead {
    public Node head;

    public void insert(int value) {
        Node newNode = new Node(value);
        if (head == null) {
            head = newNode;
        } else {
            Node temp = head;
            while (temp.next != null) {
                temp = temp.next;
            }
            temp.next = newNode;
        }
    }
}
2）带头节点的链表 
public class NodeWithHead {
    public int data;
    public NodeWithHead next;

    public NodeWithHead(int data) {
        this.data = data;
        this.next = null;
    }
}

public class LinkedListWithHead {
    private NodeWithHead head;

    public LinkedListWithHead() {
        head = new NodeWithHead(-1);  // 初始化头节点
    }

    public void insert(int value) {
        NodeWithHead newNode = new NodeWithHead(value);
        NodeWithHead temp = head;
        while (temp.next != null) {
            temp = temp.next;
        }
        temp.next = newNode;
    }
}
释放锁的过程
将当前节点插入到等待对列之后，会使当前线程释放 lock，由 fullyRelease 方法实现，源码如下： 
final int fullyRelease(Node node) {
 //释放锁失败为true，释放锁成功为false
 boolean failed = true;
 try {
     //获取当前锁的state
  int savedState = getState();
  //释放锁成功的话
  if (release(savedState)) {
   failed = false;
   return savedState;
  } else {
   throw new IllegalMonitorStateException();
  }
 } finally {
  if (failed)
   //释放锁失败的话将节点状态置为取消
   node.waitStatus = Node.CANCELLED;
 }
}
这段代码也很容易理解，调用 AQS 的模板方法 release 释放 AQS 的同步状态并且唤醒在同步队列中头节点的后继节点引用的线程，如果释放成功则正常返回，若失败的话就抛出异常。
怎么从await方法中退出
现在回过头再来看 await 方法，其中有这样一段逻辑： 
while (!isOnSyncQueue(node)) {
	// 3. 当前线程进入到等待状态
    LockSupport.park(this);
    if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
        break;
}
isOnSyncQueue 方法用于判断当前线程所在的 Node 是否在同步队列中。
如果当前节点的 waitStatus=-2，说明它在等待队列中，返回 false；如果当前节点有前驱节点，则证明它在 AQS 队列中，但是前驱节点为空，说明它是头节点，而头节点是不参与锁竞争的，也返回 false。如果当前节点既不在等待队列中，又不是 AQS 中的头节点且存在 next 节点，说明它存在于 AQS 中，直接返回 true。看一下同步队列与等待队列的关系图：
当线程第一次调用 condition.await 方法时，会进入到这个 while 循环，然后通过 LockSupport.park(this) 使当前线程进入等待状态，那么要想退出 await，第一个前提条件就是要先退出这个 while 循环，出口就只两个地方：
  1. 走到 break 退出 while 循环；
  2. while 循环中的逻辑判断为 false。
出现第 1 种情况的条件是，当前等待的线程被中断后代码会走到 break 退出，第 2 种情况是当前节点被移动到了同步队列中（即另外一个线程调用了 condition 的 signal 或者 signalAll 方法），while 中逻辑判断为 false 后结束 while 循环。
总结一下，退出 await 方法的前提条件是当前线程被中断或者调用 condition.signal 或者 condition.signalAll 使当前节点移动到同步队列后。
当退出 while 循环后会调用acquireQueued(node, savedState)，该方法的作用是在自旋过程中线程不断尝试获取同步状态，直到成功（线程获取到 lock）。这样也说明了退出 await 方法必须是已经获得了 condition 引用（关联）的 lock。await 方法示意图如下：
如图，调用 condition.await 方法的线程必须是已经获得了 lock 的线程，也就是当前线程是同步队列中的头节点。调用该方法后会使得当前线程所封装的 Node 尾插入到等待队列中。
超时机制的支持condition 还额外支持超时机制，使用者可调用 awaitNanos、awaitUtil 这两个方法，实现原理基本上与 AQS 中的 tryAcquire 方法如出一辙。不响应中断的支持要想不响应中断可以调用 condition.awaitUninterruptibly() 方法，该方法的源码如下： 
public final void awaitUninterruptibly() {
    Node node = addConditionWaiter();
    int savedState = fullyRelease(node);
    boolean interrupted = false;
    while (!isOnSyncQueue(node)) {
        LockSupport.park(this);
        if (Thread.interrupted())
            interrupted = true;
    }
    if (acquireQueued(node, savedState) || interrupted)
        selfInterrupt();
}
这段方法与上面的 await 方法基本一致，只不过减少了对中断的处理。
# java # 开发语言
Logo
2048 AI社区

有“AI”的1024 = 2048，欢迎大家加入2048 AI社区

更多推荐

AI文学影像创意策划：后现代视角下的方法论

原则1：暴露而非隐藏传统：隐藏创作过程，呈现完美结果后现代：暴露创作过程，质疑"完美"原则2：质疑而非确认传统：提供答案和意义后现代：提出问题和悖论原则3：碎片而非整体传统：追求叙事的完整性后现代：拥抱碎片和不确定性原则4：游戏而非严肃传统：严肃对待主题后现代：用游戏和反讽处理严肃主题原则5：多元而非单一传统：单一视角和声音后现代：多重视角和声音。

avatar 2048 AI社区
cover

2026年AI甘特图工具深度对比：帮你选择最合适的甘特图软件

avatar 2048 AI社区

2026 最新企业选型指南：如何找到适配业务分析的 AI 智能体平台

Mano 作为“灵巧手”负责 SOTA 级的 GUI 操作，Cito 作为“决策脑”负责数据分析，配合 FA 框架调度，确保全流程透明、可追溯，解决了企业缺乏行业 Know-how 的痛点。在这个阶段，不仅要有“脑”，更要有“手”，能看懂报表也能操作 ERP 的智能体，才是企业真正需要的。每家企业的智能体都有其独特的优势和特点，企业在选择时，需要根据自身的需求、业务场景以及预算等多方面因素综合考量

avatar 2048 AI社区