compact1, compact2, compact3

java.util.concurrent.locks

Class AbstractQueuedSynchronizer.ConditionObject

java.lang.Object

java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject

All Implemented Interfaces:

Serializable ， Condition

Enclosing class:

AbstractQueuedSynchronizer

public class AbstractQueuedSynchronizer.ConditionObject
extends Object
implements Condition, Serializable

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

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

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

另请参见：

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 - 如果 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