模块 java.base

软件包 java.util.concurrent.locks

Class AbstractQueuedLongSynchronizer.ConditionObject

java.lang.Object

java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject

实现的所有接口

Serializable ， Condition

Enclosing class:

AbstractQueuedLongSynchronizer

public class AbstractQueuedLongSynchronizer.ConditionObjectextends Objectimplements Condition, Serializable

AbstractQueuedLongSynchronizer的条件实施，作为Lock实施的基础。

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

这个类是Serializable，但是所有字段都是瞬态的，因此反序列化条件没有服务员。

从以下版本开始：

1.6

另请参见：

Serialized Form

构造方法摘要

构造方法

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

方法摘要

变量和类型	方法	描述
void	await()	实现可中断条件等待。
boolean	await(long time, TimeUnit unit)	实现定时条件等待。
long	awaitNanos(long nanosTimeout)	实现定时条件等待。
void	awaitUninterruptibly()	实现不间断的条件等待。
boolean	awaitUntil(Date deadline)	实现绝对定时条件等待。
protected Collection<Thread>	getWaitingThreads()	返回包含可能在此条件上等待的那些线程的集合。
protected int	getWaitQueueLength()	返回在此条件下等待的线程数的估计值。
protected boolean	hasWaiters()	查询是否有任何线程正在等待这种情况。
void	signal()	将等待时间最长的线程（如果存在）从此条件的等待队列移动到拥有锁的等待队列。
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()

将等待时间最长的线程（如果存在）从此条件的等待队列移动到拥有锁的等待队列。

Specified by:

signal在界面 Condition

异常

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

signalAll

public final void signalAll()

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

Specified by:

signalAll在界面 Condition

异常

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

awaitUninterruptibly

public final void awaitUninterruptibly()

实现不间断的条件等待。

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

Specified by:

awaitUninterruptibly在界面 Condition

await

public final void await()                 throws InterruptedException

实现可中断条件等待。

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

Specified by:

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(long)来重新获取 。
6. 如果在步骤4中被阻止时被中断，则抛出InterruptedException。

Specified by:

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(long)重新获取 。
6. 如果在步骤4中被阻止时被中断，则抛出InterruptedException。
7. 如果在步骤4中被阻止时超时，则返回false，否则返回true。

Specified by:

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(long)重新获取 。
6. 如果在步骤4中被阻止时被中断，则抛出InterruptedException。
7. 如果在步骤4中被阻止时超时，则返回false，否则返回true。

Specified by:

await in interface 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