compact1, compact2, compact3

java.util.concurrent.locks

Class AbstractQueuedLongSynchronizer.ConditionObject

java.lang.Object

java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject

All Implemented Interfaces:

Serializable ， Condition

Enclosing class:

AbstractQueuedLongSynchronizer

public class AbstractQueuedLongSynchronizer.ConditionObject
extends Object
implements Condition, Serializable

Condition实现AbstractQueuedLongSynchronizer作为基础Lock实施。

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

这个类是Serializable，但是所有字段都是暂时的，所以反序列化的条件没有服务器。

从以下版本开始：

1.6

另请参见：

Serialized Form

构造方法摘要

构造方法

Constructor and Description
ConditionObject() 创建一个新的 ConditionObject实例。

方法摘要

Modifier and Type	Method and Description
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() 将所有线程从这个条件的等待队列移动到拥有锁的等待队列。

Methods inherited from class 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为单位的最长等待时间

结果

估计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 ，否则 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在界面 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