模块 java.base
包 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
AbstractQueuedSynchronizer 的一个版本，其中同步状态保持为 long。此类具有与 AbstractQueuedSynchronizer 完全相同的结构、属性和方法，但所有与状态相关的参数和结果都定义为 long 而不是 int 。在创建需要 64 位状态的多级锁和屏障等同步器时，此类可能很有用。

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

自从：
1.6
参见：

  • 构造方法详细信息

    • AbstractQueuedLongSynchronizer

      public 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)
      尝试以独占模式获取。此方法应查询对象的状态是否允许以独占模式获取它，如果允许则获取它。

      此方法始终由执行获取的线程调用。如果此方法报告失败，acquire 方法可能会将线程排队（如果它尚未排队），直到其他线程发出释放信号为止。这可用于实现方法 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)
      尝试以共享模式获取。此方法应查询对象的状态是否允许以共享模式获取它，如果允许则获取它。

      此方法始终由执行获取的线程调用。如果此方法报告失败，acquire 方法可能会将线程排队（如果它尚未排队），直到其他线程发出释放信号为止。

      默认实现抛出 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()
      查询是否有线程争用过这个同步器；也就是说，如果 acquire 方法曾经被阻塞。

      在此实现中，此操作以恒定时间返回。

      返回：
      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 后，另一个线程有可能赢得入队竞争。

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

       
 protected boolean tryAcquire(long 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()
      返回标识此同步器及其状态的字符串。括号中的状态包括字符串 "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 - 如果条件为空