Module  java.base
软件包  java.util.concurrent.locks

Class AbstractQueuedLongSynchronizer

  • All Implemented Interfaces:
    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如果成功。 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 - 如果不支持共享模式

      • 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 。 这种同步器的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如果当前线程前面有一个排队的线程，而 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
        结果
        识别此同步器的字符串以及其状态

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