Module java.base
Package java.util.concurrent.locks

Class AbstractQueuedLongSynchronizer

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
另请参见:

  • Constructor Details

    • AbstractQueuedLongSynchronizer

      public AbstractQueuedLongSynchronizer()
      子类调用的构造函数。

  • Method Details

    • 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表示实际值不等于期望值。

    • tryAcquire

      protected boolean tryAcquire(long arg)
      尝试以独占模式获取。此方法应查询对象的状态是否允许以独占模式获取，并在允许时获取。

      此方法始终由执行获取的线程调用。如果此方法报告失败，则获取方法可能会将线程排队，如果尚未排队，则直到被其他线程的释放信号唤醒。这可用于实现方法Lock.tryLock()。

      默认实现会抛出UnsupportedOperationException。

      参数:
      arg - 获取参数。此值始终是传递给获取方法的值，或者是在条件等待时保存的值。否则，该值未解释，可以表示任何您喜欢的内容。
      返回:
      如果成功则返回true。成功后，此对象已被获取。
      抛出:
      IllegalMonitorStateException - 如果获取会使此同步器处于非法状态。为了使同步正常工作，必须以一致的方式抛出此异常。
      UnsupportedOperationException - 如果不支持独占模式

    • tryRelease

      protected boolean tryRelease(long arg)
      尝试设置状态以反映以独占模式释放。

      此方法始终由执行释放的线程调用。

      默认实现会抛出UnsupportedOperationException。

      参数:
      arg - 释放参数。此值始终是传递给释放方法的值，或者在进入条件等待时的当前状态值。否则，该值未解释，可以表示任何您喜欢的内容。
      返回:
      如果此对象现在处于完全释放状态，则返回true，以便任何等待的线程可以尝试获取；否则返回false。
      抛出:
      IllegalMonitorStateException - 如果释放会使此同步器处于非法状态。为了使同步正常工作，必须以一致的方式抛出此异常。
      UnsupportedOperationException - 如果不支持独占模式

    • tryAcquireShared

      protected long tryAcquireShared(long arg)
      尝试以共享模式获取。此方法应查询对象的状态是否允许以共享模式获取，并在允许时获取。

      此方法始终由执行获取的线程调用。如果此方法报告失败，则获取方法可能会将线程排队，如果尚未排队，则直到被其他线程的释放信号唤醒。

      默认实现会抛出UnsupportedOperationException。

      参数:
      arg - 获取参数。此值始终是传递给获取方法的值，或者是在条件等待时保存的值。否则，该值未解释，可以表示任何您喜欢的内容。
      返回:
      失败时返回负值；在共享模式获取成功但后续共享模式获取无法成功时返回零；在共享模式获取成功且后续共享模式获取也可能成功时返回正值，此时后续等待的线程必须检查可用性。（支持三种不同的返回值使得此方法可以在有时仅执行独占操作的情况下使用。）成功后，此对象已被获取。
      抛出:
      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 - 如果线程为null

    • hasQueuedPredecessors

      public final boolean hasQueuedPredecessors()
      查询是否有任何线程等待获取比当前线程更长的时间。

      调用此方法等效于（但可能比以下方法更有效）：

       
 getFirstQueuedThread() != Thread.currentThread()
   && hasQueuedThreads()

      请注意，由于中断和超时可能随时发生，返回true并不保证其他线程会在当前线程之前获取。同样，可能会有另一个线程在此方法返回false后赢得排队的竞赛，因为队列为空。

      此方法旨在供公平同步器使用，以避免插队。这样的同步器的tryAcquire(long)方法应返回false，并且如果此方法返回true（除非这是一个可重入获取），则其tryAcquireShared(long)方法应返回负值。例如，公平、可重入、独占模式同步器的tryAcquire方法可能如下所示：

       
 protected boolean tryAcquire(long arg) {
   if (isHeldExclusively()) {
     // 可重入获取；增加持有计数
     return true;
   } else if (hasQueuedPredecessors()) {
     return false;
   } else {
     // 尝试正常获取
   }
 }
      返回：
      如果有排队在当前线程之前的线程，则返回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 - 如果条件为null

    • hasWaiters

      public final boolean hasWaiters(AbstractQueuedLongSynchronizer.ConditionObject condition)
      查询是否有任何线程正在等待与此同步器关联的给定条件。请注意，因为超时和中断可能随时发生，返回true并不保证将来的signal会唤醒任何线程。此方法主要设计用于监视系统状态。
      参数：
      condition - 条件
      返回：
      如果有任何等待的线程则返回true
      抛出：
      IllegalMonitorStateException - 如果没有持有独占同步
      IllegalArgumentException - 如果给定条件与此同步器不相关
      NullPointerException - 如果条件为null

    • 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 - 如果条件为null