模块  java.base
软件包  java.util.concurrent.locks

Class AbstractQueuedLongSynchronizer

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

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

    从以下版本开始：
    1.6
    另请参见：
    Serialized Form

    • 构造方法详细信息

      • 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 - 如果不支持共享模式

      • acquire

        public final void acquire​(long arg)
        以独占模式获取，忽略中断。 通过至少调用一次tryAcquire(long)实现 ，返回成功。 否则线程排队，可能反复阻塞和解除阻塞，调用tryAcquire(long)直到成功。 该方法可用于实现方法Lock.lock() 。
        参数
        arg - 获取参数。 此值传达给tryAcquire(long)但未解释，可以表示您喜欢的任何内容。

      • 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 - 如果当前线程被中断

      • acquireShared

        public final void acquireShared​(long arg)
        以共享模式获取，忽略中断。 首先调用至少一次tryAcquireShared(long)实现 ，返回成功。 否则线程排队，可能反复阻塞和解除阻塞，调用tryAcquireShared(long)直到成功。
        参数
        arg - 获取参数。 此值传达给tryAcquireShared(long)但未解释，可以表示您喜欢的任何内容。

      • 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
        结果
        标识此同步器的字符串及其状态

      • getWaitQueueLength

        public final int getWaitQueueLength​(AbstractQueuedLongSynchronizer.ConditionObject condition)
        返回与此同步器关联的给定条件上等待的线程数的估计值。 请注意，由于超时和中断可能在任何时间发生，因此估计仅用作实际服务员数量的上限。 此方法设计用于监视系统状态，而不是用于同步控制。
        参数
        condition - 条件
        结果
        估计的等待线程数
        异常
        IllegalMonitorStateException - 如果未保留独占同步
        IllegalArgumentException - 如果给定条件与此同步器无关
        NullPointerException - 如果条件为null