AbstractQueuedLongSynchronizer.ConditionObject

目录搜索

文字

概述

软件包

类

使用

树

已过时

索引

帮助

Java^TM 2 Platform
Standard Ed. 6

上一个类 下一个类

框架 无框架

摘要：嵌套 | 字段 | 构造方法 | 方法

详细信息：字段 | 构造方法 | 方法

java.util.concurrent.locks
类 AbstractQueuedLongSynchronizer.ConditionObject

java.lang.Object
  java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject

所有已实现的接口：: Serializable, Condition

正在封闭类：: AbstractQueuedLongSynchronizer

public class AbstractQueuedLongSynchronizer.ConditionObject
extends Object
implements Condition, Serializable

作为 Lock 实现基础的 AbstractQueuedLongSynchronizer 的条件实现。

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

此类是可序列化的，但所有字段都是瞬态的，因此序列化条件没有等待线程。

从以下版本开始：: 1.6
另请参见：: 序列化表格

构造方法摘要
`AbstractQueuedLongSynchronizer.ConditionObject()` 创建一个新的 `ConditionObject` 实例。

方法摘要
`void`	`await()` 实现可中断的条件等待。
`boolean`	`await(long time, TimeUnit unit)` 实现定时条件等待。
`long`	`awaitNanos(long nanosTimeout)` 实现定时条件等待。
`void`	`awaitUninterruptibly()` 实现不可中断的条件等待。
`boolean`	`awaitUntil(Date deadline)` 实现绝对定时条件等待。
`protected Collection<Thread>`	`getWaitingThreads()` 返回一个 collection，该 collection 包含那些正在此条件等待的线程。
`protected int`	`getWaitQueueLength()` 返回正在此条件等待的线程估计数。
`protected boolean`	`hasWaiters()` 查询是否有线程正在此条件等待。
`void`	`signal()` 将等待时间最长的线程（如果有）从此条件的等待队列移动到拥有锁的等待队列。
`void`	`signalAll()` 将所有线程从此条件的等待队列移动到拥有锁的等待队列。

从类 java.lang.Object 继承的方法
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

构造方法详细信息

public AbstractQueuedLongSynchronizer.ConditionObject()

创建一个新的 ConditionObject 实例。

方法详细信息

signal

public final void signal()

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

指定者：: 接口 Condition 中的 signal

抛出：: IllegalMonitorStateException - 如果 AbstractQueuedLongSynchronizer.isHeldExclusively() 返回 false

signalAll

public final void signalAll()

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

指定者：: 接口 Condition 中的 signalAll

抛出：: IllegalMonitorStateException - 如果 AbstractQueuedLongSynchronizer.isHeldExclusively() 返回 false

awaitUninterruptibly

public final void awaitUninterruptibly()

实现不可中断的条件等待。

保存 AbstractQueuedLongSynchronizer.getState() 返回的锁定状态
以保存的状态作为参数调用 AbstractQueuedLongSynchronizer.release(long)，如果调用失败，则抛出 IllegalMonitorStateException。
在收到信号之前，一直阻塞
以保存的状态作为参数调用 AbstractQueuedLongSynchronizer.acquire(long) 的特定版本重新获取。

指定者：: 接口 Condition 中的 awaitUninterruptibly

await

public final void await()
                 throws InterruptedException

实现可中断的条件等待。

如果当前线程被中断，则抛出 InterruptedException
保存 AbstractQueuedLongSynchronizer.getState() 返回的锁定状态
以保存的状态作为参数调用 AbstractQueuedLongSynchronizer.release(long)，如果调用失败，则抛出 IllegalMonitorStateException。
在收到信号或中断之前，一直阻塞
以保存的状态作为参数调用 AbstractQueuedLongSynchronizer.acquire(long) 的特定版本重新获取。
如果步骤 4 的阻塞过程中发生中断，则抛出异常

指定者：: 接口 Condition 中的 await

抛出：: InterruptedException - 如果当前线程被中断（并且支持中断线程挂起）

awaitNanos

public final long awaitNanos(long nanosTimeout)
                      throws InterruptedException

实现定时条件等待。

如果当前线程被中断，则抛出 InterruptedException
保存 AbstractQueuedLongSynchronizer.getState() 返回的锁定状态
以保存的状态作为参数调用 AbstractQueuedLongSynchronizer.release(long)，如果调用失败，则抛出 IllegalMonitorStateException。
在收到信号、中断或超时之前，一直阻塞
以保存的状态作为参数调用 AbstractQueuedLongSynchronizer.acquire(long) 的特定版本重新获取。
如果步骤 4 的阻塞过程中发生中断，则抛出 InterruptedException

指定者：: 接口 Condition 中的 awaitNanos

参数：: nanosTimeout - 等待的最长时间，以毫微秒为单位
返回：: nanosTimeout 值减去花费在等待此方法的返回结果的时间的估算。正值可以用作对此方法进行后续调用的参数，来完成等待所需时间结束。小于等于零的值表示没有剩余时间。
抛出：: InterruptedException - 如果当前线程被中断（并且支持中断线程挂起）

awaitUntil

public final boolean awaitUntil(Date deadline)
                         throws InterruptedException

实现绝对定时条件等待。

如果当前线程被中断，则抛出 InterruptedException
保存 AbstractQueuedLongSynchronizer.getState() 返回的锁定状态
以保存的状态作为参数调用 AbstractQueuedLongSynchronizer.release(long)，如果调用失败，则抛出 IllegalMonitorStateException。
在收到信号、中断或超时之前，一直阻塞
以保存的状态作为参数调用 AbstractQueuedLongSynchronizer.acquire(long) 的特定版本重新获取。
如果步骤 4 的阻塞过程中发生中断，则抛出 InterruptedException
如果步骤 4 的阻塞过程中发生超时，则返回 false，否则返回 true

指定者：: 接口 Condition 中的 awaitUntil

参数：: deadline - 一直处于等待状态的绝对时间
返回：: 如果在返回时已经到达最后期限，则返回 false，否则返回 true
抛出：: InterruptedException - 如果当前线程被中断（并且支持中断线程挂起）

await

public final boolean await(long time,
                           TimeUnit unit)
                    throws InterruptedException

实现定时条件等待。

如果当前线程被中断，则抛出 InterruptedException
保存 AbstractQueuedLongSynchronizer.getState() 返回的锁定状态
以保存的状态作为参数调用 AbstractQueuedLongSynchronizer.release(long)，如果调用失败，则抛出 IllegalMonitorStateException。
在收到信号、中断或超时之前，一直阻塞
以保存的状态作为参数调用 AbstractQueuedLongSynchronizer.acquire(long) 的特定版本重新获取。
如果步骤 4 的阻塞过程中发生中断，则抛出 InterruptedException
如果步骤 4 的阻塞过程中发生超时，则返回 false，否则返回 true

指定者：: 接口 Condition 中的 await

参数：: time - 最长等待时间; unit - time 参数的时间单位

返回：

如果在从此方法返回前检测到等待时间超时，则返回 false，否则返回 true

抛出：

InterruptedException - 如果当前线程被中断（并且支持中断线程挂起）

hasWaiters

protected final boolean hasWaiters()

查询是否有线程正在此条件等待。实现 AbstractQueuedLongSynchronizer.hasWaiters(java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject)。

返回：: true 如果没有任何正在等待的线程
抛出：: IllegalMonitorStateException - 如果 AbstractQueuedLongSynchronizer.isHeldExclusively() 返回 false

getWaitQueueLength

protected final int getWaitQueueLength()

返回正在此条件等待的线程估计数。实现

AbstractQueuedLongSynchronizer.getWaitQueueLength(java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject)

。

返回：: 等待线程的估计数
抛出：: IllegalMonitorStateException - 如果 AbstractQueuedLongSynchronizer.isHeldExclusively() 返回 false

getWaitingThreads

protected final Collection<Thread> getWaitingThreads()

返回一个 collection，该 collection 包含那些正在此条件等待的线程。实现

AbstractQueuedLongSynchronizer.getWaitingThreads(java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject)

。

返回：: 线程 collection
抛出：: IllegalMonitorStateException - 如果 AbstractQueuedLongSynchronizer.isHeldExclusively() 返回 false

概述