java.util.concurrent.locks
类 AbstractQueuedLongSynchronizer

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

所有已实现的接口：

Serializable

public abstract class AbstractQueuedLongSynchronizer
     

      extends 
      AbstractOwnableSynchronizer
     
     

      implements 
      Serializable
     

以 long 形式维护同步状态的一个 AbstractQueuedSynchronizer 版本。此类具有的结构、属性和方法与 AbstractQueuedSynchronizer 完全相同，但所有与状态相关的参数和结果都定义为 long 而不是 int。当创建需要 64 位状态的多级别锁和屏障等同步器时，此类很有用。

有关用法说明和示例，请参阅 AbstractQueuedSynchronizer。

从以下版本开始：

1.6

另请参见：

序列化表格

嵌套类摘要

class

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

构造方法摘要

protected

AbstractQueuedLongSynchronizer() 创建一个初始同步状态为 0 的新 AbstractQueuedLongSynchronizer 实例。

方法摘要

void	acquire(long arg) 以独占模式获取，忽略中断。
void	acquireInterruptibly(long arg) 以独占模式获取，如果被中断则中止。
void	acquireShared(long arg) 以共享模式获取，忽略中断。
void	acquireSharedInterruptibly(long arg) 以共享模式获取，如果被中断则中止。
protected boolean	compareAndSetState(long expect, long update) 如果当前状态值等于预期值，则以原子方式将同步状态设置为给定的更新值。
Collection<Thread>	getExclusiveQueuedThreads() 返回一个 collection，该 collection 包含正以独占模式等待获取的线程。
Thread	getFirstQueuedThread() 返回队列中第一个（等待时间最长的）线程；如果当前没有将任何线程加入队列，则返回 null。
Collection<Thread>	getQueuedThreads() 返回一个 collection，该 collection 包含正在等待获取的线程。
int	getQueueLength() 返回等待获取的线程估计数。
Collection<Thread>	getSharedQueuedThreads() 返回一个 collection，该 collection 包含正以共享模式等待获取的线程。
protected long	getState() 返回同步状态的当前值。
Collection<Thread>	getWaitingThreads(AbstractQueuedLongSynchronizer.ConditionObject condition) 返回一个 collection，该 collection 包含那些正在与此同步器关联的给定条件上等待的线程。
int	getWaitQueueLength(AbstractQueuedLongSynchronizer.ConditionObject condition) 返回正在与此同步器关联的给定条件上等待的线程估计数。
boolean	hasContended() 查询是否有线程曾经为获取此同步器而发生争用；也就是说，是否某个 acquire 方法曾被阻塞。
boolean	hasQueuedThreads() 查询是否有等待获取的线程。
boolean	hasWaiters(AbstractQueuedLongSynchronizer.ConditionObject condition) 查询是否有线程正在与此同步器关联的给定条件上等待。
protected boolean	isHeldExclusively() 如果对于当前（调用的）线程，同步是以独占方式进行的，则返回 true。
boolean	isQueued(Thread thread) 如果给定线程当前已加入队列，则返回 true。
boolean	owns(AbstractQueuedLongSynchronizer.ConditionObject condition) 查询给定 ConditionObject 是否使用此同步器作为它的锁。
boolean	release(long arg) 以独占模式释放。
boolean	releaseShared(long arg) 以共享模式释放。
protected void	setState(long newState) 设置同步状态的值。
String	toString() 返回标识此同步器及其状态的字符串。
protected boolean	tryAcquire(long arg) 尝试在独占模式下获取。
boolean	tryAcquireNanos(long arg, long nanosTimeout) 尝试以独占模式获取，如果被中断则中止，如果超过给定超时期则失败。
protected long	tryAcquireShared(long arg) 尝试在共享模式下获取。
boolean	tryAcquireSharedNanos(long arg, long nanosTimeout) 尝试以共享模式获取，如果被中断则中止，如果超过给定超时期则失败。
protected boolean	tryRelease(long arg) 尝试设置状态来反映独占模式下的释放。
protected boolean	tryReleaseShared(long arg) 尝试设置状态来反映共享模式下的释放。

从类 java.util.concurrent.locks.AbstractOwnableSynchronizer 继承的方法

getExclusiveOwnerThread, setExclusiveOwnerThread

从类 java.lang.Object 继承的方法

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

构造方法详细信息

AbstractQueuedLongSynchronizer

protected AbstractQueuedLongSynchronizer()

创建一个初始同步状态为 0 的新 AbstractQueuedLongSynchronizer 实例。

方法详细信息

getState

protected final long getState()

返回同步状态的当前值。此操作的内存语义 (memory semantics) 为 volatile 读。

返回：

当前状态值

setState

protected final void setState(long newState)

设置同步状态的值。此操作的内存语义为 volatile 写。

参数：

newState - 新的状态值

compareAndSetState

protected final boolean compareAndSetState(long expect,
                                           long update)

如果当前状态值等于预期值，则以原子方式将同步状态设置为给定的更新值。此操作的内存语义为 volatile 写和读。

参数：

expect - 预期值

update - 新值

返回：

如果成功，则返回 true。返回 false 指示实际值与预期值不相等。

tryAcquire

protected boolean tryAcquire(long arg)

尝试在独占模式下获取。此方法应该查询是否允许在独占模式下获取对象状态，如果允许，则获取它。

此方法总是由执行获取的线程调用。如果此方法报告失败，则 acquire 方法可以将线程加入队列（如果它还没有加入队列），直到收到其他线程的释放信号为止。可以使用此方法来实现 Lock.tryLock() 方法。

默认实现将抛出 UnsupportedOperationException。

参数：

arg - 获取参数。此值总是传递给 acquire 方法的那个值，或者是保存在某个条件等待条目上的值。该值在其他方面没有解释，可以表示任何内容。

返回：

如果成功，则返回 true。在成功时，此对象已经被获取。

抛出：

IllegalMonitorStateException - 如果获取操作会将此同步器变为非法状态。为了同步的正常运行，必须以统一的方式抛出此异常。

UnsupportedOperationException - 如果不支持独占模式

tryRelease

protected boolean tryRelease(long arg)

尝试设置状态来反映独占模式下的释放。

此方法总是由执行释放的线程调用。

默认实现将抛出 UnsupportedOperationException。

参数：

arg - 释放参数。此值总是传递给 release 方法的那个值，或者是某个条件等待条目上的当前状态值。该值在其他方面没有解释，可以表示任何内容。

返回：

如果此对象现在处于完全释放状态，从而任何等待的线程都可以尝试获取，则返回 true；否则返回 false。

抛出：

IllegalMonitorStateException - 如果释放操作会将此同步器变为非法状态。为了同步的正常运行，必须以统一的方式抛出此异常。

UnsupportedOperationException - 如果不支持独占模式

tryAcquireShared

protected long tryAcquireShared(long arg)

尝试在共享模式下获取。此方法应该查询是否允许在共享模式下获取对象状态，如果允许，则获取它。

此方法总是由执行获取的线程调用。如果此方法报告失败，则 acquire 方法可以将线程加入队列（如果它还没有加入队列），直到收到其他线程的释放信号为止。

默认实现将抛出 UnsupportedOperationException。

参数：

arg - 获取参数。此值总是传递给 acquire 方法的那个值，或者是保存在某个条件等待条目上的值。该值在其他方面没有解释，可以表示任何内容。

返回：

在失败时返回负值；如果在共享模式下获取成功，但后续共享模式下的获取无法成功，则返回 0；如果在共享模式下获取成功，并且后续共享模式下的获取也能成功（在这种情况下，后续等待线程必须检查可用性），则返回正值。（支持三个不同返回值使得此方法可以在偶尔以独占方式进行获取的上下文中使用。）在成功时，此对象已经被获取。

抛出：

IllegalMonitorStateException - 如果获取操作会将此同步器变为非法状态。为了同步的正常运行，必须以统一的方式抛出此异常。

UnsupportedOperationException - 如果不支持共享模式

tryReleaseShared

protected boolean tryReleaseShared(long arg)

尝试设置状态来反映共享模式下的释放。

此方法总是由执行释放的线程调用。

默认实现将抛出 UnsupportedOperationException。

参数：

arg - 释放参数。此值总是传递给 release 方法的那个值，或者是某个条件等待条目上的当前状态值。该值在其他方面没有解释，可以表示任何内容。

返回：

如果此共享模式下的释放允许等待的获取（共享或独占）获得成功，则返回 true；否则返回 false

抛出：

IllegalMonitorStateException - 如果释放操作会将此同步器变为非法状态。为了同步的正常运行，必须以统一的方式抛出此异常。

UnsupportedOperationException - 如果不支持共享模式

isHeldExclusively

protected boolean isHeldExclusively()

如果对于当前（调用的）线程，同步是以独占方式进行的，则返回 true。此方法是在每次调用非等待 AbstractQueuedLongSynchronizer.ConditionObject 方法时调用的。（等待方法则调用 release(long)。）

默认实现将抛出 UnsupportedOperationException。此方法只在 AbstractQueuedLongSynchronizer.ConditionObject 方法中进行内部调用，因此，如果不使用条件，则不需要定义它。

返回：

如果同步是以独占方式进行的，则返回 true；否则返回 false

抛出：

UnsupportedOperationException - 如果不支持这些条件

acquire

public final void acquire(long arg)

以独占模式获取，忽略中断。实现此方法要至少调用一次 tryAcquire(long)，并在成功时返回。否则，在成功之前，线程将加入队列，可能反复处于阻塞或未阻塞状态，并一直调用 tryAcquire(long)。可以使用此方法来实现 Lock.lock() 方法。

参数：

arg - 获取参数。此值被传送给 tryAcquire(long)，但在其他方面没有解释，可以表示任何内容。

acquireInterruptibly

public final void acquireInterruptibly(long arg)
                                throws InterruptedException

以独占模式获取，如果被中断则中止。实现此方法首先要检查中断状态，然后至少调用一次 tryAcquire(long)，并在成功时返回。否则，在成功或线程中断之前，线程将加入队列，可能反复处于阻塞或未阻塞状态，并一直调用 tryAcquire(long)。可以使用此方法来实现 Lock.lockInterruptibly() 方法。

参数：

arg - 获取参数。此值被传送给 tryAcquire(long)，但在其他方面没有解释，可以表示任何内容。

抛出：

InterruptedException - 如果当前线程被中断

tryAcquireNanos

public final boolean tryAcquireNanos(long arg,
                                     long nanosTimeout)
                              throws InterruptedException

尝试以独占模式获取，如果被中断则中止，如果超过给定超时期则失败。实现此方法首先要检查中断状态，然后至少调用一次 tryAcquire(long)，并在成功时返回。否则，在成功、线程中断或超过超时期之前，线程将加入队列，可能反复处于阻塞或未阻塞状态，并一直调用 tryAcquire(long)。可以使用此方法来实现 Lock.tryLock(long, TimeUnit) 方法。

参数：

arg - 获取参数。此值被传送给 tryAcquire(long)，但在其他方面没有解释，可以表示任何内容。

nanosTimeout - 等待的最大毫微秒数

返回：

如果获取，则返回 true；如果超时，则返回 false

抛出：

InterruptedException - 如果当前线程被中断

release

public final boolean release(long arg)

以独占模式释放。如果 tryRelease(long) 返回 true，则通过取消一个或多个线程的阻塞来实现此方法。可以使用此方法来实现 Lock.unlock() 方法。

参数：

arg - 释放参数。此值被传送给 tryRelease(long)，但在其他方面没有解释，可以表示任何内容。

返回：

从 tryRelease(long) 返回的值

acquireShared

public final void acquireShared(long arg)

以共享模式获取，忽略中断。实现此方法要至少调用一次 tryAcquireShared(long)，并在成功时返回。否则，在成功之前，线程将加入队列，可能反复处于阻塞或未阻塞状态，并一直调用 tryAcquireShared(long)。

参数：

arg - 获取参数。此值被传送给 tryAcquireShared(long)，但在其他方面没有解释，可以表示任何内容。

acquireSharedInterruptibly

public final void acquireSharedInterruptibly(long arg)
                                      throws InterruptedException

以共享模式获取，如果被中断则中止。实现此方法首先要检查中断状态，然后至少调用一次 tryAcquireShared(long)，并在成功时返回。否则，在成功或线程中断之前，线程将加入队列，可能反复处于阻塞或未阻塞状态，并一直调用 tryAcquireShared(long)。

参数：

arg - 获取参数。此值被传送给 tryAcquireShared(long)，但在其他方面没有解释，可以表示任何内容。

抛出：

InterruptedException - 如果当前线程被中断

tryAcquireSharedNanos

public final boolean tryAcquireSharedNanos(long arg,
                                           long nanosTimeout)
                                    throws InterruptedException

尝试以共享模式获取，如果被中断则中止，如果超过给定超时期则失败。实现此方法首先要检查中断状态，然后至少调用一次 tryAcquireShared(long)，并在成功时返回。否则，在成功、线程中断或超过超时期之前，线程将加入队列，可能反复处于阻塞或未阻塞状态，并一直调用 tryAcquireShared(long)。

参数：

arg - 获取参数。此值被传送给 tryAcquireShared(long)，但在其他方面没有解释，可以表示任何内容。

nanosTimeout - 等待的最大毫微秒数

返回：

如果获取，则返回 true；如果超时，则返回 false

抛出：

InterruptedException - 如果当前线程被中断

releaseShared

public final boolean releaseShared(long arg)

以共享模式释放。如果 tryReleaseShared(long) 返回 true，则通过取消一个或多个线程的阻塞来实现此方法。

参数：

arg - 释放参数。此值被传送给 tryReleaseShared(long)，但在其他方面没有解释，可以表示任何内容。

返回：

从 tryReleaseShared(long) 中返回的值

hasQueuedThreads

public final boolean hasQueuedThreads()

查询是否有等待获取的线程。注意，随时可能因为中断和超时而导致取消操作，所以返回 true 并不能保证任何其他线程能一直获取。

在此实现中，此操作是以固定时间返回的。

返回：

如果有其他线程正在等待获取，则返回 true

hasContended

public final boolean hasContended()

查询是否有线程曾经为获取此同步器而发生争用；也就是说，是否某个 acquire 方法曾被阻塞。

在此实现中，此操作是以固定时间返回的。

返回：

如果曾经出现争用，则返回 true

getFirstQueuedThread

public final Thread getFirstQueuedThread()

返回队列中第一个（等待时间最长的）线程；如果当前没有将任何线程加入队列，则返回 null。

在此实现中，此操作通常是以固定时间返回的，但是，如果其他线程正在并发修改该队列，则可能出现循环争用。

返回：

队列中第一个（等待时间最长的）线程；如果当前没有将任何线程加入队列，则返回 null

isQueued

public final boolean isQueued(Thread thread)

如果给定线程当前已加入队列，则返回 true。

此实现将遍历队列，以确定给定线程是否存在。

参数：

thread - 线程

返回：

如果给定线程在队列中，则返回 true

抛出：

NullPointerException - 如果线程为 null

getQueueLength

public final int getQueueLength()

返回等待获取的线程估计数。该值只是一个估计值，因为在此方法遍历内部数据结构时，线程的数量可以动态地变化。此方法是为监视系统状态而设计的，不是为同步控制设计的。

返回：

等待获取的线程估计数

getQueuedThreads

public final Collection<Thread> getQueuedThreads()

返回一个 collection，该 collection 包含正在等待获取的线程。因为在构造此结果时，实际线程集可能动态地变化，所以返回的 collection 只是一个尽可能准确的估计值。所返回 collection 中的元素没有特定的顺序。设计此方法是为了便于构造子类，提供更多的监视设施。

返回：

线程 collection

getExclusiveQueuedThreads

public final Collection<Thread> getExclusiveQueuedThreads()

返回一个 collection，该 collection 包含正以独占模式等待获取的线程。此方法的属性与 getQueuedThreads() 相同，但它只返回那些因独占获取而等待的线程。

返回：

线程 collection

getSharedQueuedThreads

public final Collection<Thread> getSharedQueuedThreads()

返回一个 collection，该 collection 包含正以共享模式等待获取的线程。此方法的属性与 getQueuedThreads() 相同，但它只返回那些因共享获取而等待的线程。

返回：

线程 collection

toString

public String toString()

返回标识此同步器及其状态的字符串。该状态用括号括起来，包括 String "State ="，后跟 getState() 的当前值，再后面是 "nonempty" 或 "empty"，具体取决于队列是否为空。

覆盖：

类 Object 中的 toString

返回：

标识此同步器及其状态的字符串

owns

public final boolean owns(AbstractQueuedLongSynchronizer.ConditionObject condition)

查询给定 ConditionObject 是否使用此同步器作为它的锁。

参数：

condition - 条件

返回：

如果具备此条件，则返回 true

抛出：

NullPointerException - 如果 condition 为 null

hasWaiters

public final boolean hasWaiters(AbstractQueuedLongSynchronizer.ConditionObject condition)

查询是否有线程正在与此同步器关联的给定条件上等待。注意，因为随时可能发生超时和中断，所以返回 true 并不能保证将来某个 signal 将唤醒任何线程。此方法主要是为了监视系统状态而设计的。

参数：

condition - 条件

返回：

如果有正在等待的线程，则返回 true。

抛出：

IllegalMonitorStateException - 如果不进行独占同步

IllegalArgumentException - 如果给定条件与此同步器没有关联

NullPointerException - 如果 condition 为 null

getWaitQueueLength

public final int getWaitQueueLength(AbstractQueuedLongSynchronizer.ConditionObject condition)

返回正在与此同步器关联的给定条件上等待的线程估计数。注意，因为随时可能发生超时和中断，所以估计值只是实际等待线程数的上限。此方法是为监视系统状态而设计的，不是为同步控制设计的。

参数：

condition - 条件

返回：

等待线程的估计数

抛出：

IllegalMonitorStateException - 如果不进行独占同步

IllegalArgumentException - 如果给定条件与此同步器没有关联

NullPointerException - 如果 condition 为 null

getWaitingThreads

public final Collection<Thread> getWaitingThreads(AbstractQueuedLongSynchronizer.ConditionObject condition)

返回一个 collection，该 collection 包含那些正在与此同步器关联的给定条件上等待的线程。因为在构造此结果时，实际线程集可能动态地变化，所以返回的 collection 只是一个尽可能准确的估计值。所返回 collection 中的元素没有特定的顺序。

参数：

condition - 条件

返回：

线程 collection

抛出：

IllegalMonitorStateException - 如果不进行独占同步

IllegalArgumentException - 如果给定条件与此同步器没有关联

NullPointerException - 如果 condition 为 null