模块 java.base
包 java.util.concurrent.locks

类 AbstractQueuedSynchronizer.ConditionObject

java.lang.Object
java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject
所有已实现的接口：
Serializable , Condition
封闭类：
AbstractQueuedSynchronizer
public class AbstractQueuedSynchronizer.ConditionObject extends Object implements Condition , Serializable
AbstractQueuedSynchronizer 的条件实现作为 Lock 实现的基础。

此类的方法文档描述了机制，而不是从 Lock 和 Condition 用户的角度来看的行为规范。此类的导出版本通常需要附有描述依赖于相关 AbstractQueuedSynchronizer 条件语义的文档。

此类是可序列化的，但所有字段都是瞬态的，因此反序列化条件没有等待者。

参见：

  • 构造方法总结

    构造方法
    构造方法
    描述
    ConditionObject()
    创建一个新的 ConditionObject 实例。

  • 方法总结

    修饰符和类型
    方法
    描述
    final void
    await()
    实现可中断条件等待。
    final boolean
    await(long time, TimeUnit unit)
    实现定时条件等待。
    final long
    awaitNanos(long nanosTimeout)
    实现定时条件等待。
    final void
    awaitUninterruptibly()
    实现不间断条件等待。
    final boolean
    awaitUntil(Date deadline)
    实现绝对定时条件等待。
    protected final Collection<Thread>
    getWaitingThreads()
    返回一个集合，其中包含可能正在等待此条件的那些线程。
    protected final int
    getWaitQueueLength()
    返回等待此条件的线程数的估计值。
    protected final boolean
    hasWaiters()
    查询是否有任何线程正在等待此条件。
    final void
    signal()
    将等待时间最长的线程（如果存在）从该条件的等待队列移动到拥有锁的等待队列。
    final void
    signalAll()
    将所有线程从该条件的等待队列移动到拥有锁的等待队列。

    在类 java.lang.Object 中声明的方法

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

  • 构造方法详细信息

    • ConditionObject

      public ConditionObject()
      创建一个新的 ConditionObject 实例。

  • 方法详情

    • signal

      public final void signal()
      将等待时间最长的线程（如果存在）从该条件的等待队列移动到拥有锁的等待队列。
      指定者：
      signal 在接口 Condition 中
      抛出：
      IllegalMonitorStateException - 如果 AbstractQueuedSynchronizer.isHeldExclusively() 返回 false

    • signalAll

      public final void signalAll()
      将所有线程从该条件的等待队列移动到拥有锁的等待队列。
      指定者：
      signalAll 在接口 Condition 中
      抛出：
      IllegalMonitorStateException - 如果 AbstractQueuedSynchronizer.isHeldExclusively() 返回 false

    • awaitUninterruptibly

      public final void awaitUninterruptibly()
      实现不间断条件等待。
      1. 保存 AbstractQueuedSynchronizer.getState() 返回的锁定状态。
      2. 以保存的状态作为参数调用 AbstractQueuedSynchronizer.release(int) ，如果失败则抛出 IllegalMonitorStateException。
      3. 阻止直到发出信号。
      4. 通过以保存的状态作为参数调用 AbstractQueuedSynchronizer.acquire(java.util.concurrent.locks.AbstractQueuedSynchronizer.Node, int, boolean, boolean, boolean, long) 的特殊版本来重新获取。
      指定者：
      awaitUninterruptibly 在接口 Condition 中

    • await

      public final void await() throws InterruptedException
      实现可中断条件等待。
      1. 如果当前线程被中断，则抛出 InterruptedException。
      2. 保存 AbstractQueuedSynchronizer.getState() 返回的锁定状态。
      3. 以保存的状态作为参数调用 AbstractQueuedSynchronizer.release(int) ，如果失败则抛出 IllegalMonitorStateException。
      4. 阻塞直到发出信号或被打断。
      5. 通过以保存的状态作为参数调用 AbstractQueuedSynchronizer.acquire(java.util.concurrent.locks.AbstractQueuedSynchronizer.Node, int, boolean, boolean, boolean, long) 的特殊版本来重新获取。
      6. 如果在步骤 4 中阻塞时被中断，则抛出 InterruptedException。
      指定者：
      await 在接口 Condition 中
      抛出：
      InterruptedException - 如果当前线程被中断（并且支持中断线程挂起）

    • awaitNanos

      public final long awaitNanos(long nanosTimeout) throws InterruptedException
      实现定时条件等待。
      1. 如果当前线程被中断，则抛出 InterruptedException。
      2. 保存 AbstractQueuedSynchronizer.getState() 返回的锁定状态。
      3. 以保存的状态作为参数调用 AbstractQueuedSynchronizer.release(int) ，如果失败则抛出 IllegalMonitorStateException。
      4. 阻塞直到发出信号、中断或超时。
      5. 通过以保存的状态作为参数调用 AbstractQueuedSynchronizer.acquire(java.util.concurrent.locks.AbstractQueuedSynchronizer.Node, int, boolean, boolean, boolean, long) 的特殊版本来重新获取。
      6. 如果在步骤 4 中阻塞时被中断，则抛出 InterruptedException。
      指定者：
      awaitNanos 在接口 Condition 中
      参数：
      nanosTimeout - 等待的最长时间，以纳秒为单位
      返回：
      nanosTimeout 值的估计值减去等待从此方法返回所花费的时间。正值可用作后续调用此方法的参数以完成等待所需时间。小于或等于零的值表示没有时间剩余。
      抛出：
      InterruptedException - 如果当前线程被中断（并且支持中断线程挂起）

    • awaitUntil

      public final boolean awaitUntil(Date  deadline) throws InterruptedException
      实现绝对定时条件等待。
      1. 如果当前线程被中断，则抛出 InterruptedException。
      2. 保存 AbstractQueuedSynchronizer.getState() 返回的锁定状态。
      3. 以保存的状态作为参数调用 AbstractQueuedSynchronizer.release(int) ，如果失败则抛出 IllegalMonitorStateException。
      4. 阻塞直到发出信号、中断或超时。
      5. 通过以保存的状态作为参数调用 AbstractQueuedSynchronizer.acquire(java.util.concurrent.locks.AbstractQueuedSynchronizer.Node, int, boolean, boolean, boolean, long) 的特殊版本来重新获取。
      6. 如果在步骤 4 中阻塞时被中断，则抛出 InterruptedException。
      7. 如果在步骤 4 中阻塞时超时，则返回 false，否则返回 true。
      指定者：
      awaitUntil 在接口 Condition 中
      参数：
      deadline - 等待的绝对时间
      返回：
      false 如果截止日期已过返回，否则 true
      抛出：
      InterruptedException - 如果当前线程被中断（并且支持中断线程挂起）

    • await

      public final boolean await(long time, TimeUnit  unit) throws InterruptedException
      实现定时条件等待。
      1. 如果当前线程被中断，则抛出 InterruptedException。
      2. 保存 AbstractQueuedSynchronizer.getState() 返回的锁定状态。
      3. 以保存的状态作为参数调用 AbstractQueuedSynchronizer.release(int) ，如果失败则抛出 IllegalMonitorStateException。
      4. 阻塞直到发出信号、中断或超时。
      5. 通过以保存的状态作为参数调用 AbstractQueuedSynchronizer.acquire(java.util.concurrent.locks.AbstractQueuedSynchronizer.Node, int, boolean, boolean, boolean, long) 的特殊版本来重新获取。
      6. 如果在步骤 4 中阻塞时被中断，则抛出 InterruptedException。
      7. 如果在步骤 4 中阻塞时超时，则返回 false，否则返回 true。
      指定者：
      await 在接口 Condition 中
      参数：
      time - 最长时间等待
      unit - time 参数的时间单位
      返回：
      false 如果在从方法返回之前可检测到等待时间已经过去，否则 true
      抛出：
      InterruptedException - 如果当前线程被中断（并且支持中断线程挂起）

    • hasWaiters

      protected final boolean hasWaiters()
      查询是否有任何线程正在等待此条件。实施 AbstractQueuedSynchronizer.hasWaiters(ConditionObject) 。
      返回：
      true 如果有任何等待线程
      抛出：
      IllegalMonitorStateException - 如果 AbstractQueuedSynchronizer.isHeldExclusively() 返回 false

    • getWaitQueueLength

      protected final int getWaitQueueLength()
      返回等待此条件的线程数的估计值。实施 AbstractQueuedSynchronizer.getWaitQueueLength(ConditionObject) 。
      返回：
      等待线程的估计数量
      抛出：
      IllegalMonitorStateException - 如果 AbstractQueuedSynchronizer.isHeldExclusively() 返回 false

    • getWaitingThreads

      protected final Collection <Thread > getWaitingThreads()
      返回一个集合，其中包含可能正在等待此条件的那些线程。实施 AbstractQueuedSynchronizer.getWaitingThreads(ConditionObject) 。
      返回：
      线程的集合
      抛出：
      IllegalMonitorStateException - 如果 AbstractQueuedSynchronizer.isHeldExclusively() 返回 false