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

实现的所有接口

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

从以下版本开始：

1.6

另请参见：

Serialized Form

嵌套类汇总

嵌套类
变量和类型	类	描述
`class`	`AbstractQueuedLongSynchronizer.ConditionObject`	`AbstractQueuedLongSynchronizer`的条件实现，作为`Lock`实现的基础。

构造方法摘要

构造方法
变量	构造器	描述
`protected`	`AbstractQueuedLongSynchronizer()`	创建一个初始同步状态为零的新 `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()`	返回包含可能等待以独占模式获取的线程的集合。
`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)`	尝试将状态设置为反映共享模式下的发布。

声明方法的类 java.util.concurrent.locks.AbstractOwnableSynchronizer
getExclusiveOwnerThread, setExclusiveOwnerThread

声明方法的类 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如果成功。错误返回表示实际值不等于预期值。
  - tryAcquire
```
protected boolean tryAcquire(long arg)
```
    尝试以独占模式获取。此方法应查询对象的状态是否允许以独占模式获取它，如果是，则获取它。
    执行获取的线程始终调用此方法。如果此方法报告失败，则获取方法可以对线程进行排队（如果它尚未排队），直到通过某个其他线程的释放来发出信号。这可以用于实现方法Lock.tryLock() 。
    
    默认实现抛出UnsupportedOperationException 。
    
    参数
    
    arg - 获取参数。此值始终是传递给acquire方法的值，或者是条件wait的条目时保存的值。否则，该值无法解释，可以代表您喜欢的任何内容。
    
    结果
    
    true如果成功。成功后，此对象已被获得。
    
    异常
    
    IllegalMonitorStateException - 如果获取将此同步器置于非法状态。必须以一致的方式抛出此异常才能使同步正常工作。
    
    UnsupportedOperationException - 如果不支持独占模式
  - tryRelease
```
protected boolean tryRelease(long arg)
```
    尝试将状态设置为以独占模式反映发布。
    执行发布的线程始终调用此方法。
    
    默认实现抛出UnsupportedOperationException 。
    
    参数
    
    arg - 发布参数。此值始终是传递给释放方法的值，或者是在进入条件等待时的当前状态值。否则，该值无法解释，可以代表您喜欢的任何内容。
    
    结果
    
    true如果此对象现在处于完全释放状态，那么任何等待的线程都可能尝试获取; 和false否则。
    
    异常
    
    IllegalMonitorStateException - 如果释放将此同步器置于非法状态。必须以一致的方式抛出此异常才能使同步正常工作。
    
    UnsupportedOperationException - 如果不支持独占模式
  - tryAcquireShared
```
protected long tryAcquireShared(long arg)
```
    尝试以共享模式获取。此方法应查询对象的状态是否允许在共享模式下获取它，如果是，则获取它。
    执行获取的线程始终调用此方法。如果此方法报告失败，则获取方法可以对线程进行排队（如果它尚未排队），直到通过某个其他线程的释放来发出信号。
    
    默认实现抛出UnsupportedOperationException 。
    
    参数
    
    arg - 获取参数。此值始终是传递给acquire方法的值，或者是条件wait的条目时保存的值。否则，该值无法解释，可以代表您喜欢的任何内容。
    
    结果
    
    失败的负面价值; 如果在共享模式下获取成功但没有后续的共享模式获取可以成功，则为零; 如果在共享模式下获取成功并且后续共享模式获取也可能成功，则为正值，在这种情况下，后续等待线程必须检查可用性。（支持三个不同的返回值使得此方法可用于仅在有时仅采取行动的上下文中。）成功后，此对象已被获取。
    
    异常
    
    IllegalMonitorStateException - 如果获取将此同步器置于非法状态。必须以一致的方式抛出此异常才能使同步正常工作。
    
    UnsupportedOperationException - 如果不支持共享模式
  - tryReleaseShared
```
protected boolean tryReleaseShared(long arg)
```
    尝试将状态设置为反映共享模式下的发布。
    执行发布的线程始终调用此方法。
    
    默认实现抛出UnsupportedOperationException 。
    
    参数
    
    arg - 发布参数。此值始终是传递给释放方法的值，或者是在进入条件等待时的当前状态值。否则，该值无法解释，可以代表您喜欢的任何内容。
    
    结果
    
    true如果此共享模式的发布可能允许等待获取（共享或独占）成功; 和false否则
    
    异常
    
    IllegalMonitorStateException - 如果释放将此同步器置于非法状态。必须以一致的方式抛出此异常才能使同步正常工作。
    
    UnsupportedOperationException - 如果不支持共享模式
  - isHeldExclusively
```
protected boolean isHeldExclusively()
```
    如果同步仅针对当前（调用）线程保持，则返回true 。每次调用AbstractQueuedLongSynchronizer.ConditionObject方法时都会调用此方法。
    默认实现抛出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()
```
    查询是否有任何线程争用获取此同步器; 也就是说，如果获取方法曾被阻止。
    在此实现中，此操作以恒定时间返回。
    
    结果
    
    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 。如果此方法返回true （除非这是可重入获取），此类同步器的tryAcquire(long)方法应返回false ，并且其tryAcquireShared(long)方法应返回负值。例如，公平，可重入，独占模式同步器的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如果当前线程之前有一个排队的线程， 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()
```
    返回标识此同步器的字符串及其状态。括号中的状态包括String "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 - 如果条件为null
  - getWaitingThreads
```
public final Collection<Thread> getWaitingThreads(AbstractQueuedLongSynchronizer.ConditionObject condition)
```
    返回一个集合，其中包含可能正在等待与此同步器关联的给定条件的那些线程。因为实际的线程集可能在构造此结果时动态更改，所以返回的集合仅是尽力而为的估计。返回集合的元素没有特定的顺序。
    
    参数
    
    condition - 条件
    
    结果
    
    线程集合
    
    异常
    
    IllegalMonitorStateException - 如果未保留独占同步
    
    IllegalArgumentException - 如果给定条件与此同步器无关
    
    NullPointerException - 如果条件为空

Class AbstractQueuedLongSynchronizer

嵌套类汇总

构造方法摘要

方法摘要

声明方法的类 java.util.concurrent.locks.AbstractOwnableSynchronizer

声明方法的类 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