模块 java.base

软件包 java.util.concurrent.locks

Class AbstractQueuedSynchronizer.ConditionObject

java.lang.Object

java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject

实现的所有接口

Serializable ， Condition

Enclosing class:

AbstractQueuedSynchronizer

public class AbstractQueuedSynchronizer.ConditionObject
extends Object
implements Condition, Serializable

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

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

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

另请参见：

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 - 如果 AbstractQueuedSynchronizer.isHeldExclusively()返回 false

signalAll

public final void signalAll()

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

Specified by:

signalAll ，界面 Condition

异常

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

awaitUninterruptibly

public final void awaitUninterruptibly()

实现不间断的条件等待。

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

Specified by:

awaitUninterruptibly ，界面 Condition

await

public final void await()
                 throws InterruptedException

实现可中断条件等待。

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

Specified by:

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

Specified by:

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(int)重新获取 。
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. 保存由AbstractQueuedSynchronizer.getState()返回的锁定状态。
3. 以保存状态作为参数调用AbstractQueuedSynchronizer.release(int) ，如果失败则抛出IllegalMonitorStateException。
4. 阻止直至发出信号，中断或超时。
5. 通过调用保存状态作为参数的专用版本AbstractQueuedSynchronizer.acquire(int)重新获取 。
6. 如果在步骤4中被阻止时被中断，则抛出InterruptedException。
7. 如果在步骤4中被阻止时超时，则返回false，否则返回true。

Specified by:

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