模块 java.base

包 java.util.concurrent.locks

类 AbstractQueuedLongSynchronizer.ConditionObject

java.lang.Object

java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject

所有已实现的接口：

Serializable , Condition

封闭类：

AbstractQueuedLongSynchronizer

public class AbstractQueuedLongSynchronizer.ConditionObject extends Object implements Condition , Serializable 
      

AbstractQueuedLongSynchronizer 的条件实现作为 Lock 实现的基础。

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

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

参见：

• Serialized Form

构造方法总结

构造方法

构造方法	描述
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 - 如果 AbstractQueuedLongSynchronizer.isHeldExclusively() 返回 false

signalAll

public final void signalAll()
            

将所有线程从该条件的等待队列移动到拥有锁的等待队列。

指定者：

signalAll 在接口 Condition 中

抛出：

IllegalMonitorStateException - 如果 AbstractQueuedLongSynchronizer.isHeldExclusively() 返回 false

awaitUninterruptibly

public final void awaitUninterruptibly()
            

实现不间断条件等待。

1. 保存 AbstractQueuedLongSynchronizer.getState() 返回的锁定状态。
2. 以保存的状态作为参数调用 AbstractQueuedLongSynchronizer.release(long) ，如果失败则抛出 IllegalMonitorStateException。
3. 阻止直到发出信号。
4. 通过以保存的状态作为参数调用 AbstractQueuedLongSynchronizer.acquire(java.util.concurrent.locks.AbstractQueuedLongSynchronizer.Node, long, boolean, boolean, boolean, long) 的特殊版本来重新获取。

指定者：

awaitUninterruptibly 在接口 Condition 中

await

public final void await() throws InterruptedException 
            

实现可中断条件等待。

1. 如果当前线程被中断，则抛出 InterruptedException。
2. 保存 AbstractQueuedLongSynchronizer.getState() 返回的锁定状态。
3. 以保存的状态作为参数调用 AbstractQueuedLongSynchronizer.release(long) ，如果失败则抛出 IllegalMonitorStateException。
4. 阻塞直到发出信号或被打断。
5. 通过以保存的状态作为参数调用 AbstractQueuedLongSynchronizer.acquire(java.util.concurrent.locks.AbstractQueuedLongSynchronizer.Node, long, boolean, boolean, boolean, long) 的特殊版本来重新获取。
6. 如果在步骤 4 中阻塞时被中断，则抛出 InterruptedException。

指定者：

await 在接口 Condition 中

抛出：

InterruptedException - 如果当前线程被中断（并且支持中断线程挂起）

awaitNanos

public final long awaitNanos(long nanosTimeout) throws InterruptedException 
            

实现定时条件等待。

1. 如果当前线程被中断，则抛出 InterruptedException。
2. 保存 AbstractQueuedLongSynchronizer.getState() 返回的锁定状态。
3. 以保存的状态作为参数调用 AbstractQueuedLongSynchronizer.release(long) ，如果失败则抛出 IllegalMonitorStateException。
4. 阻塞直到发出信号、中断或超时。
5. 通过以保存的状态作为参数调用 AbstractQueuedLongSynchronizer.acquire(java.util.concurrent.locks.AbstractQueuedLongSynchronizer.Node, long, boolean, boolean, boolean, long) 的特殊版本来重新获取。
6. 如果在步骤 4 中阻塞时被中断，则抛出 InterruptedException。

指定者：

awaitNanos 在接口 Condition 中

参数：

nanosTimeout - 等待的最长时间，以纳秒为单位

返回：

nanosTimeout 值的估计值减去等待从此方法返回所花费的时间。正值可用作后续调用此方法的参数以完成等待所需时间。小于或等于零的值表示没有时间剩余。

抛出：

InterruptedException - 如果当前线程被中断（并且支持中断线程挂起）

awaitUntil

public final boolean awaitUntil(Date  deadline) throws InterruptedException 
            

实现绝对定时条件等待。

1. 如果当前线程被中断，则抛出 InterruptedException。
2. 保存 AbstractQueuedLongSynchronizer.getState() 返回的锁定状态。
3. 以保存的状态作为参数调用 AbstractQueuedLongSynchronizer.release(long) ，如果失败则抛出 IllegalMonitorStateException。
4. 阻塞直到发出信号、中断或超时。
5. 通过以保存的状态作为参数调用 AbstractQueuedLongSynchronizer.acquire(java.util.concurrent.locks.AbstractQueuedLongSynchronizer.Node, long, 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. 保存 AbstractQueuedLongSynchronizer.getState() 返回的锁定状态。
3. 以保存的状态作为参数调用 AbstractQueuedLongSynchronizer.release(long) ，如果失败则抛出 IllegalMonitorStateException。
4. 阻塞直到发出信号、中断或超时。
5. 通过以保存的状态作为参数调用 AbstractQueuedLongSynchronizer.acquire(java.util.concurrent.locks.AbstractQueuedLongSynchronizer.Node, long, boolean, boolean, boolean, long) 的特殊版本来重新获取。
6. 如果在步骤 4 中阻塞时被中断，则抛出 InterruptedException。
7. 如果在步骤 4 中阻塞时超时，则返回 false，否则返回 true。

指定者：

await 在接口 Condition 中

参数：

time - 最长时间等待

unit - time 参数的时间单位

返回：

false 如果在从方法返回之前可检测到等待时间已经过去，否则 true

抛出：

InterruptedException - 如果当前线程被中断（并且支持中断线程挂起）

hasWaiters

protected final boolean hasWaiters()
            

查询是否有任何线程正在等待此条件。实施 AbstractQueuedLongSynchronizer.hasWaiters(ConditionObject) 。

返回：

true 如果有任何等待线程

抛出：

IllegalMonitorStateException - 如果 AbstractQueuedLongSynchronizer.isHeldExclusively() 返回 false

getWaitQueueLength

protected final int getWaitQueueLength()
            

返回等待此条件的线程数的估计值。实施 AbstractQueuedLongSynchronizer.getWaitQueueLength(ConditionObject) 。

返回：

等待线程的估计数量

抛出：

IllegalMonitorStateException - 如果 AbstractQueuedLongSynchronizer.isHeldExclusively() 返回 false

getWaitingThreads

protected final Collection <Thread > getWaitingThreads()
            

返回一个集合，其中包含可能正在等待此条件的那些线程。实施 AbstractQueuedLongSynchronizer.getWaitingThreads(ConditionObject) 。

返回：

线程的集合

抛出：

IllegalMonitorStateException - 如果 AbstractQueuedLongSynchronizer.isHeldExclusively() 返回 false