AbstractQueuedLongSynchronizer (Java Platform SE 8 )

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

All Implemented Interfaces:

Serializable
```
public abstract class AbstractQueuedLongSynchronizer
extends AbstractOwnableSynchronizer
implements Serializable
```
AbstractQueuedSynchronizer的一个版本，其中同步状态保持为long 。此类具有完全相同的结构，属性和为方法AbstractQueuedSynchronizer与所有的状态有关的参数和结果被定义为例外long而非int 。当创建同步器（例如需要64位状态的多级锁和障碍）时，此类可能很有用。
有关使用说明和示例，请参阅AbstractQueuedSynchronizer 。

从以下版本开始：

1.6

另请参见：

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`AbstractQueuedLongSynchronizer.ConditionObject` Condition实现`AbstractQueuedLongSynchronizer`作为基础`Lock`实施。

构造方法摘要

构造方法
Modifier	Constructor and Description
`protected`	`AbstractQueuedLongSynchronizer()` 创建一个初始同步状态为零的新的 `AbstractQueuedLongSynchronizer`实例。

方法摘要

所有方法接口方法具体的方法
Modifier and Type	Method and Description
`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()` 返回一个包含可能正在等待以独占模式获取的线程的集合。
`Thread`	`getFirstQueuedThread()` 返回队列中第一个（等待时间最长的）线程，或 `null`如果没有线程正在排队。
`Collection<Thread>`	`getQueuedThreads()` 返回一个包含可能正在等待获取的线程的集合。
`int`	`getQueueLength()` 返回等待获取的线程数的估计。
`Collection<Thread>`	`getSharedQueuedThreads()` 返回包含可能正在等待在共享模式下获取的线程的集合。
`protected long`	`getState()` 返回同步状态的当前值。
`Collection<Thread>`	`getWaitingThreads(AbstractQueuedLongSynchronizer.ConditionObject condition)` 返回一个集合，其中包含可能正在等待与此同步器相关联的给定条件的线程。
`int`	`getWaitQueueLength(AbstractQueuedLongSynchronizer.ConditionObject condition)` 返回等待与此同步器相关联的给定条件的线程数量的估计。
`boolean`	`hasContended()` 查询任何线程是否有争取获取此同步器; 那就是收购方法是否被阻止。
`boolean`	`hasQueuedPredecessors()` 查询任何线程是否等待获取比当前线程更长的时间。
`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)` 尝试将状态设置为以共享模式反映发布。

Methods inherited from class java.util.concurrent.locks.AbstractOwnableSynchronizer
getExclusiveOwnerThread, setExclusiveOwnerThread

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- 构造方法详细信息
  - AbstractQueuedLongSynchronizer
```
protected AbstractQueuedLongSynchronizer()
```
    创建一个初始同步状态为零的新的 AbstractQueuedLongSynchronizer实例。
- 方法详细信息
  - getState
```
protected final long getState()
```
    返回同步状态的当前值。这个操作有一个volatile读取的内存语义。
    
    结果
    
    当前状态值
  - setState
```
protected final void setState(long newState)
```
    设置同步状态的值。此操作具有volatile写入的记忆语义。
    
    参数
    
    newState - 新的状态值
  - compareAndSetState
```
protected final boolean compareAndSetState(long expect,
                                           long update)
```
    如果当前状态值等于期望值，则将同步状态原子地设置为给定的更新值。这个操作具有一个volatile读写的记忆语义。
    
    参数
    
    expect - 预期值
    
    update - 新价值
    
    结果
    
    true如果成功。 False return表示实际值不等于预期值。
  - tryAcquire
```
protected boolean tryAcquire(long arg)
```
    尝试以独占模式获取。该方法应该查询对象的状态是否允许以独占模式获取，如果是，则获取它。
    该方法总是由执行获取的线程调用。如果此方法报告失败，则获取方法可能将线程排队（如果尚未排队），直到被其他线程释放为止。这可以用于实现方法Lock.tryLock() 。
    
    默认实现会抛出UnsupportedOperationException 。
    
    参数
    
    arg - 获取的论据。该值始终是传递给获取方法的值，或者是进入条件等待时保存的值。该值否则无法解释，可以代表您喜欢的任何内容。
    
    结果
    
    true如果成功。一旦成功，这个对象就被收购了。
    
    异常
    
    IllegalMonitorStateException - 如果获取将使该同步器处于非法状态。必须以一致的方式抛出此异常，以使同步正常工作。
    
    UnsupportedOperationException - 如果不支持排他模式
  - tryRelease
```
protected boolean tryRelease(long arg)
```
    尝试设置状态以独占模式反映版本。
    该方法总是由执行释放的线程调用。
    
    默认实现会抛出UnsupportedOperationException 。
    
    参数
    
    arg - 释放参数。该值始终是传递给release方法的值，或者进入条件等待时的当前状态值。该值否则无法解释，可以代表您喜欢的任何内容。
    
    结果
    
    true如果此对象现在处于完全释放状态，以便任何等待的线程可能尝试获取; 和false否则。
    
    异常
    
    IllegalMonitorStateException - 如果释放将使此同步器处于非法状态。必须以一致的方式抛出此异常，以使同步正常工作。
    
    UnsupportedOperationException - 如果不支持独占模式
  - tryAcquireShared
```
protected long tryAcquireShared(long arg)
```
    尝试以共享模式获取。该方法应该查询对象的状态是否允许在共享模式下获取该对象，如果是这样，就可以获取它。
    该方法总是由执行获取的线程调用。如果此方法报告失败，则获取方法可能将线程排队（如果尚未排队），直到被其他线程释放为止。
    
    默认实现会抛出UnsupportedOperationException 。
    
    参数
    
    arg - 获取的论据。该值始终是传递给获取方法的值，或者是进入条件等待时保存的值。该值否则无法解释，可以代表您喜欢的任何内容。
    
    结果
    
    失败的负值如果在共享模式下获取成功但没有后续共享模式获取可以成功，则为零; 并且如果以共享模式获取成功并且随后的共享模式获取可能成功，则为正值，在这种情况下，后续等待线程必须检查可用性。（支持三种不同的返回值使得这种方法可以在仅获取有时只能完全执行的上下文中使用。）成功后，该对象已被获取。
    
    异常
    
    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返回不能保证任何其他线程将获得。
    在这个实现中，这个操作返回恒定的时间。
    
    结果
    
    true如果可能有其他线程等待获取
  - hasContended
```
public final boolean hasContended()
```
    查询任何线程是否有争取获取此同步器; 那就是收购方法是否被阻止。
    在这个实现中，这个操作返回恒定的时间。
    
    结果
    
    true如果有 true话
  - getFirstQueuedThread
```
public final Thread getFirstQueuedThread()
```
    返回队列中第一个（等待时间最长的）线程，或null如果没有线程正在排队。
    在这个实现中，这个操作通常在常量时间内返回，但如果其他线程同时修改队列，则可以在争用时迭代。
    
    结果
    
    在队列中的第一个（等待时间最长的）螺纹，或 null如果没有线程当前排队
  - isQueued
```
public final boolean isQueued(Thread thread)
```
    如果给定的线程当前排队，则返回true。
    该实现遍历队列以确定给定线程的存在。
    
    参数
    
    thread - 线程
    
    结果
    
    true如果给定的线程在队列上
    
    异常
    
    NullPointerException - 如果线程为空
  - hasQueuedPredecessors
```
public final boolean hasQueuedPredecessors()
```
    查询任何线程是否等待获取比当前线程更长的时间。
    调用此方法等同于（但可能更有效）：
```
   getFirstQueuedThread() != Thread.currentThread() && hasQueuedThreads() 
```
    请注意，因为由于中断和超时而导致的取消可能随时发生，所以true返回不能保证其他一些线程将在当前线程之前获取。同样，由于队列为空，这个方法返回了false之后，另一个线程可能会赢得比赛排队。
    
    该方法被设计为由一个公平的同步器使用以避免barging 。这样一个同步器的tryAcquire(long)方法应该返回false ，并且它的tryAcquireShared(long)方法应该返回一个负值，如果这个方法返回true （除非这是一个可重入的获取）。例如， tryAcquire公平，可重入，独占模式同步器的方法可能如下所示：
```
   protected boolean tryAcquire(int arg) { if (isHeldExclusively()) { // A reentrant acquire; increment hold count return true; } else if (hasQueuedPredecessors()) { return false; } else { // try to acquire normally } } 
```
    结果
    
    true如果当前线程 true有一个排队的线程，而 false如果当前线程在队列的头部或队列是空的
    
    从以下版本开始：
    
    1.7
  - getQueueLength
```
public final int getQueueLength()
```
    返回等待获取的线程数的估计。该值只是一个估计，因为线程数可能会在此方法遍历内部数据结构时动态更改。该方法设计用于监控系统状态，不用于同步控制。
    
    结果
    
    估计等待获取的线程数
  - getQueuedThreads
```
public final Collection<Thread> getQueuedThreads()
```
    返回一个包含可能正在等待获取的线程的集合。因为在构建此结果时，实际的线程集可能会动态更改，所以返回的集合只是尽力而为的估计。返回的集合的元素没有特定的顺序。该方法旨在便于构建提供更广泛监控设施的子类。
    
    结果
    
    线程的收集
  - getExclusiveQueuedThreads
```
public final Collection<Thread> getExclusiveQueuedThreads()
```
    返回一个包含可能正在等待以独占模式获取的线程的集合。这具有相同的属性， getQueuedThreads() ，除了它只返回那些等待的线程由于独家获取。
    
    结果
    
    线程的收集
  - getSharedQueuedThreads
```
public final Collection<Thread> getSharedQueuedThreads()
```
    返回包含可能正在等待在共享模式下获取的线程的集合。这具有相同的特性getQueuedThreads() ，但它仅返回那些等待的线程由于共享获取。
    
    结果
    
    线程的收集
  - toString
```
public String toString()
```
    返回一个标识此同步器的字符串及其状态。括号中的状态包括字符串"State ="后跟当前值getState() ，并且"nonempty"或"empty"取决于队列是否为空。
    
    重写：
    
    toString在类别 Object
    
    结果
    
    识别此同步器的字符串以及其状态
  - owns
```
public final boolean owns(AbstractQueuedLongSynchronizer.ConditionObject condition)
```
    查询给定的ConditionObject是否将此同步器用作其锁。
    
    参数
    
    condition - 条件
    
    结果
    
    true如果拥有
    
    异常
    
    NullPointerException - 如果条件为空
  - hasWaiters
```
public final boolean hasWaiters(AbstractQueuedLongSynchronizer.ConditionObject condition)
```
    查询任何线程是否等待与此同步器相关联的给定条件。请注意，由于超时和中断可能随时发生， true返回并不能保证未来的signal将唤醒任何线程。该方法主要用于监视系统状态。
    
    参数
    
    condition - 条件
    
    结果
    
    true如果有任何等待线程
    
    异常
    
    IllegalMonitorStateException - 如果不保持独占同步
    
    IllegalArgumentException - 如果给定的条件与该同步器没有关联
    
    NullPointerException - 如果条件为空
  - getWaitQueueLength
```
public final int getWaitQueueLength(AbstractQueuedLongSynchronizer.ConditionObject condition)
```
    返回等待与此同步器相关联的给定条件的线程数量的估计。请注意，由于超时和中断可能在任何时间发生，估计仅作为实际服务员人数的上限。该方法设计用于监视系统状态，不用于同步控制。
    
    参数
    
    condition - 条件
    
    结果
    
    估计等待线程数
    
    异常
    
    IllegalMonitorStateException - 如果不保留独占同步
    
    IllegalArgumentException - 如果给定条件与此同步器没有关联
    
    NullPointerException - 如果条件为空
  - getWaitingThreads
```
public final Collection<Thread> getWaitingThreads(AbstractQueuedLongSynchronizer.ConditionObject condition)
```
    返回一个集合，其中包含可能正在等待与此同步器相关联的给定条件的线程。因为在构建此结果时，实际的线程集可能会动态更改，所以返回的集合只是尽力而为的估计。返回的集合的元素没有特定的顺序。
    
    参数
    
    condition - 条件
    
    结果
    
    线程的收集
    
    异常
    
    IllegalMonitorStateException - 如果不保留独占同步
    
    IllegalArgumentException - 如果给定的条件与该同步器没有关联
    
    NullPointerException - 如果条件为空

Class AbstractQueuedLongSynchronizer

Nested Class Summary

构造方法摘要

方法摘要

Methods inherited from class java.util.concurrent.locks.AbstractOwnableSynchronizer

Methods inherited from class java.lang.Object

构造方法详细信息

AbstractQueuedLongSynchronizer

方法详细信息

getState

setState

compareAndSetState

tryAcquire

tryRelease

tryAcquireShared

tryReleaseShared

isHeldExclusively

acquire

acquireInterruptibly

tryAcquireNanos

release

acquireShared

acquireSharedInterruptibly

tryAcquireSharedNanos

releaseShared

hasQueuedThreads

hasContended

getFirstQueuedThread

isQueued

hasQueuedPredecessors

getQueueLength

getQueuedThreads

getExclusiveQueuedThreads

getSharedQueuedThreads

toString

owns

hasWaiters

getWaitQueueLength

getWaitingThreads