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

一 AbstractQueuedSynchronizer作为一个 Lock实施的基础条件的实现。

本类的方法文档介绍了力学，而不是行为规范的角度来看，锁定和条件用户。出口版本的这类一般会需要附带文档描述的条件下，依靠语义的相关AbstractQueuedSynchronizer。

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

另请参见：

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

Constructor Detail

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中被阻塞的时候超时，返回错误，否则是真的。

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中被阻塞的时候超时，返回错误，否则是真的。

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