- java.lang.Object
-
- java.util.concurrent.locks.AbstractOwnableSynchronizer
-
- java.util.concurrent.locks.AbstractQueuedSynchronizer
-
- All Implemented Interfaces:
-
Serializable
public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements Serializable
提供一个框架,用于实现依赖先进先出(FIFO)等待队列的阻塞锁和相关同步器(信号量,事件等)。 这个类被设计为大多数类型的同步器的有用的依据,这些同步器依赖于单个原子int
值来表示状态。 子类必须定义改变此状态的受保护方法,以及根据该对象获取或释放的方式来定义该状态。 给定这些,这个类中的其他方法执行所有排队和阻塞机制。 子类可以保持其他状态字段,但只以原子方式更新int
使用方法操纵值getState()
,setState(int)
和compareAndSetState(int, int)
跟踪相对于同步。子类应定义为非公共内部助手类,用于实现其封闭类的同步属性。
AbstractQueuedSynchronizer
类不实现任何同步接口。 相反,它定义了可以通过具体锁和相关同步器适当地调用的方法,例如acquireInterruptibly(int)
来实现其公共方法。此类支持默认独占模式和共享模式。 当以独占模式获取时,尝试通过其他线程获取不能成功。 多线程获取的共享模式可能(但不需要)成功。 除了在机械意义上,这个类不理解这些差异,当共享模式获取成功时,下一个等待线程(如果存在)也必须确定它是否也可以获取。 在不同模式下等待的线程共享相同的FIFO队列。 通常,实现子类仅支持这些模式之一,但是二者可以在
ReadWriteLock
中发挥作用 。 仅支持独占或仅共享模式的子类不需要定义支持未使用模式的方法。该类定义了一个嵌套的
AbstractQueuedSynchronizer.ConditionObject
类,可以通过支持独占模式的子类用作Condition
实现,方法isHeldExclusively()
报告是否同步针对当前线程进行独占保留,使用当前getState()
值调用的方法release(int)
完全释放此对象,和acquire(int)
,给定此保存的状态值,最终将此对象恢复到其先前获取的状态。 否则AbstractQueuedSynchronizer
方法会创建这样的条件,所以如果不能满足这个约束,不要使用它。AbstractQueuedSynchronizer.ConditionObject
的行为当然取决于其同步器实现的语义。该类为内部队列提供检查,检测和监控方法,以及条件对象的类似方法。 这些可以根据需要导出到类中,使用
AbstractQueuedSynchronizer
进行同步机制。此类的序列化仅存储底层原子整数维持状态,因此反序列化对象具有空线程队列。 需要可序列化的典型子类将定义一个
readObject
方法,可以将其恢复为反序列化时的已知初始状态。用法
使用这个类用作同步的基础上,重新定义以下方法,如适用,通过检查和/或修改使用所述同步状态
这些方法中的每一个默认抛出getState()
,setState(int)
和/或compareAndSetState(int, int)
:UnsupportedOperationException
。 这些方法的实现必须是线程安全的,通常应该是短的而不是阻塞的。 定义这些方法是唯一支持使用此类的方法。 所有其他方法都被声明为final
因为它们不能独立变化。您也可以从
AbstractOwnableSynchronizer
中找到继承的方法,用于跟踪拥有独占同步器的线程。 我们鼓励您使用它们 - 这样可以使监控和诊断工具帮助用户确定哪些线程持有锁定。即使这个类基于内部FIFO队列,它也不会自动执行FIFO采集策略。 排他同步的核心形式如下:
Acquire: while (!tryAcquire(arg)) { enqueue thread if it is not already queued; possibly block current thread; } Release: if (tryRelease(arg)) unblock the first queued thread;
(共享模式类似,但可能包含级联信号。)因为在采集检查入队之前调用,所以新获取的线程可能闯入其他被阻塞和排队的。 但是,如果需要,您可以定义
tryAcquire
和/或tryAcquireShared
以通过内部调用一个或多个检查方法来禁用驳船,从而提供公平的 FIFO采购订单。 特别地,最公平同步器可以定义tryAcquire
返回false
如果hasQueuedPredecessors()
(具体地设计成由公平同步器中使用的方法)返回true
。 其他变化是可能的。吞吐量和可扩展性通常对于默认的驳船(也称为贪心 , 放弃和车队避免 )战略来说是最高的。 虽然这不能保证是公平的或无饥饿的,但较早排队的线程在稍后排队的线程之前被允许重新侦听,并且每次重新注入都有不偏不倚的机会成功接收线程。 而且,在通常的意义上,获取不要“旋转”,它们可以在阻塞之前执行
tryAcquire
多次调用,并tryAcquire
其他计算。 当独占同步只是简单地持有时,这样可以提供旋转的大部分好处,而没有大部分负债。 如果需要,您可以通过以前通过“快速路径”检查获取方法的调用进行扩充,可能预先检查hasContended()
和/或hasQueuedThreads()
,以便只有在同步器可能不被竞争的情况下才能进行。该类为同步提供了一个高效和可扩展的基础,部分原因是可以依赖于
int
状态,获取和释放参数以及内部FIFO等待队列的同步器的使用范围。 当这不足够时,您可以使用atomic
类,自己的自定义Queue
类和LockSupport
类来构建较低级别的同步器。用法示例
这是一个不可重入互斥锁类,它使用零值来表示解锁状态,一个表示锁定状态。 虽然不可重入锁不严格要求记录当前的所有者线程,但是这样做无论如何使得使用更容易监视。 它还支持条件并公开其中一种仪器方法:
class Mutex implements Lock, java.io.Serializable { // Our internal helper class private static class Sync extends AbstractQueuedSynchronizer { // Reports whether in locked state protected boolean isHeldExclusively() { return getState() == 1; } // Acquires the lock if state is zero public boolean tryAcquire(int acquires) { assert acquires == 1; // Otherwise unused if (compareAndSetState(0, 1)) { setExclusiveOwnerThread(Thread.currentThread()); return true; } return false; } // Releases the lock by setting state to zero protected boolean tryRelease(int releases) { assert releases == 1; // Otherwise unused if (getState() == 0) throw new IllegalMonitorStateException(); setExclusiveOwnerThread(null); setState(0); return true; } // Provides a Condition Condition newCondition() { return new ConditionObject(); } // Deserializes properly private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException { s.defaultReadObject(); setState(0); // reset to unlocked state } } // The sync object does all the hard work. We just forward to it. private final Sync sync = new Sync(); public void lock() { sync.acquire(1); } public boolean tryLock() { return sync.tryAcquire(1); } public void unlock() { sync.release(1); } public Condition newCondition() { return sync.newCondition(); } public boolean isLocked() { return sync.isHeldExclusively(); } public boolean hasQueuedThreads() { return sync.hasQueuedThreads(); } public void lockInterruptibly() throws InterruptedException { sync.acquireInterruptibly(1); } public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException { return sync.tryAcquireNanos(1, unit.toNanos(timeout)); } }
这是一个闩锁类,就像一个
CountDownLatch
,除了它只需要一个signal
发射。 因为锁存器是非排他的,所以它使用shared
获取和释放方法。class BooleanLatch { private static class Sync extends AbstractQueuedSynchronizer { boolean isSignalled() { return getState() != 0; } protected int tryAcquireShared(int ignore) { return isSignalled() ? 1 : -1; } protected boolean tryReleaseShared(int ignore) { setState(1); return true; } } private final Sync sync = new Sync(); public boolean isSignalled() { return sync.isSignalled(); } public void signal() { sync.releaseShared(1); } public void await() throws InterruptedException { sync.acquireSharedInterruptibly(1); } }
- 从以下版本开始:
- 1.5
- 另请参见:
- Serialized Form
-
-
Nested Class Summary
Nested Classes Modifier and Type Class 描述 class
AbstractQueuedSynchronizer.ConditionObject
条件实施AbstractQueuedSynchronizer
作为Lock
实施的基础。
-
构造方法摘要
构造方法 Modifier Constructor 描述 protected
AbstractQueuedSynchronizer()
创建一个初始同步状态为零的新的AbstractQueuedSynchronizer
实例。
-
方法摘要
所有方法 接口方法 具体的方法 Modifier and Type 方法 描述 void
acquire(int arg)
以独占模式获取,忽略中断。void
acquireInterruptibly(int arg)
以独占方式获得,如果中断,中止。void
acquireShared(int arg)
以共享模式获取,忽略中断。void
acquireSharedInterruptibly(int arg)
以共享方式获取,如果中断,中止。protected boolean
compareAndSetState(int expect, int update)
如果当前状态值等于期望值,则将同步状态原子设置为给定的更新值。Collection<Thread>
getExclusiveQueuedThreads()
返回一个包含可能正在等待以独占模式获取的线程的集合。Thread
getFirstQueuedThread()
返回队列中的第一个(最长等待)线程,如果没有线程当前排队,则null
。Collection<Thread>
getQueuedThreads()
返回一个包含可能正在等待获取的线程的集合。int
getQueueLength()
返回等待获取的线程数的估计。Collection<Thread>
getSharedQueuedThreads()
返回包含可能正在等待在共享模式下获取的线程的集合。protected int
getState()
返回同步状态的当前值。Collection<Thread>
getWaitingThreads(AbstractQueuedSynchronizer.ConditionObject condition)
返回一个集合,其中包含可能正在等待与此同步器相关联的给定条件的线程。int
getWaitQueueLength(AbstractQueuedSynchronizer.ConditionObject condition)
返回等待与此同步器相关联的给定条件的线程数量的估计。boolean
hasContended()
查询任何线程是否有争取获取此同步器; 也就是说,如果获取方法被阻止。boolean
hasQueuedPredecessors()
查询任何线程是否等待获取比当前线程更长的时间。boolean
hasQueuedThreads()
查询任何线程是否等待获取。boolean
hasWaiters(AbstractQueuedSynchronizer.ConditionObject condition)
查询任何线程是否等待与此同步器相关联的给定条件。protected boolean
isHeldExclusively()
返回true
如果同步仅针对当前(调用)线程进行。boolean
isQueued(Thread thread)
如果给定的线程当前排队,则返回true。boolean
owns(AbstractQueuedSynchronizer.ConditionObject condition)
查询给定的ConditionObject是否将此同步器用作其锁。boolean
release(int arg)
以专属模式发布。boolean
releaseShared(int arg)
以共享模式发布。protected void
setState(int newState)
设置同步状态的值。String
toString()
返回一个标识此同步器的字符串及其状态。protected boolean
tryAcquire(int arg)
尝试以独占模式获取。boolean
tryAcquireNanos(int arg, long nanosTimeout)
尝试以独占模式获取,如果中断则中止,如果给定的超时时间失败。protected int
tryAcquireShared(int arg)
尝试以共享模式获取。boolean
tryAcquireSharedNanos(int arg, long nanosTimeout)
尝试以共享模式获取,如果中断则中止,如果给定的时间超过,则失败。protected boolean
tryRelease(int arg)
尝试设置状态以独占模式反映释放。protected boolean
tryReleaseShared(int arg)
尝试将状态设置为以共享模式反映发布。-
Methods inherited from class java.util.concurrent.locks.AbstractOwnableSynchronizer
getExclusiveOwnerThread, setExclusiveOwnerThread
-
-
-
-
方法详细信息
-
getState
protected final int getState()
返回同步状态的当前值。 这个操作有volatile
读取的内存语义。- 结果
- 当前状态值
-
setState
protected final void setState(int newState)
设置同步状态的值。 此操作具有volatile
写入的内存语义。- 参数
-
newState
- 新的状态值
-
compareAndSetState
protected final boolean compareAndSetState(int expect, int update)
如果当前状态值等于期望值,则将同步状态原子设置为给定的更新值。 此操作具有volatile
读写的内存语义。- 参数
-
expect
- 期望值 -
update
- 新值 - 结果
-
true
如果成功。 False return表示实际值不等于预期值。
-
tryAcquire
protected boolean tryAcquire(int arg)
尝试以独占模式获取。 该方法应该查询对象的状态是否允许以独占模式获取,如果是,则获取它。该方法总是由执行获取的线程调用。 如果此方法报告失败,则获取方法可能将线程排队(如果尚未排队),直到被其他线程释放为止。 这可以用于实现方法
Lock.tryLock()
。默认实现抛出
UnsupportedOperationException
。- 参数
-
arg
- 获取的论据。 该值始终是传递给获取方法的值,也可以是进入条件等待时保存的值。 该值否则无法解释,可以代表您喜欢的任何内容。 - 结果
-
true
如果成功。 一旦成功,这个对象就被收购了。 - 异常
-
IllegalMonitorStateException
- 如果获取将使该同步器处于非法状态。 必须以一致的方式抛出此异常,以使同步正常工作。 -
UnsupportedOperationException
- 如果不支持独占模式
-
tryRelease
protected boolean tryRelease(int arg)
- 参数
-
arg
- 释放参数。 该值始终是传递给release方法的值,或者进入条件等待时的当前状态值。 该值否则无法解释,可以代表您喜欢的任何内容。 - 结果
-
true
如果此对象现在处于完全释放状态,以便任何等待线程可能尝试获取; 而另外false
。 - 异常
-
IllegalMonitorStateException
- 如果释放将使该同步器处于非法状态。 必须以一致的方式抛出此异常,以使同步正常工作。 -
UnsupportedOperationException
- 如果不支持独占模式
-
tryAcquireShared
protected int tryAcquireShared(int arg)
尝试以共享模式获取。 该方法应该查询对象的状态是否允许在共享模式下获取该对象,如果是这样,就可以获取它。该方法总是由执行获取的线程调用。 如果此方法报告失败,则获取方法可能将线程排队(如果尚未排队),直到被其他线程释放为止。
默认实现抛出
UnsupportedOperationException
。- 参数
-
arg
- 获取的论据。 该值始终是传递给获取方法的值,也可以是进入条件等待时保存的值。 该值否则无法解释,可以代表您喜欢的任何内容。 - 结果
- 失败的负值 如果在共享模式下获取成功但没有后续共享模式获取可以成功,则为零; 并且如果在共享模式下的获取成功并且随后的共享模式获取可能成功,则为正值,在这种情况下,后续等待线程必须检查可用性。 (支持三种不同的返回值使得这种方法可以在仅获取有时只能完全执行的上下文中使用。)成功后,该对象已被获取。
- 异常
-
IllegalMonitorStateException
- 如果获取将使该同步器处于非法状态。 必须以一致的方式抛出此异常,以使同步正常工作。 -
UnsupportedOperationException
- 如果不支持共享模式
-
tryReleaseShared
protected boolean tryReleaseShared(int arg)
- 参数
-
arg
- 释放参数。 该值始终是传递给release方法的值,或者进入条件等待时的当前状态值。 该值否则无法解释,可以代表您喜欢的任何内容。 - 结果
-
true
如果这种共享模式的释放可能允许等待获取(共享或排他)成功; 而另外false
- 异常
-
IllegalMonitorStateException
- 如果释放将使该同步器处于非法状态。 必须以一致的方式抛出此异常,以使同步正常工作。 -
UnsupportedOperationException
- 如果不支持共享模式
-
isHeldExclusively
protected boolean isHeldExclusively()
返回true
如果同步仅针对当前(调用)线程进行保存。 每次调用不等待的方法都调用此方法AbstractQueuedSynchronizer.ConditionObject
方法。 (等待方法调用release(int)
。 )默认实现抛出
UnsupportedOperationException
。 此方法仅在AbstractQueuedSynchronizer.ConditionObject
方法内部调用,因此如果不使用条件,则不需要定义该方法。- 结果
-
true
如果同步是唯一的; 否则为false
- 异常
-
UnsupportedOperationException
- 如果不支持条件
-
acquire
public final void acquire(int arg)
以独占模式获取,忽略中断。 通过调用至少一次执行tryAcquire(int)
,成功返回。 否则线程排队,可能会重复阻塞和解除阻塞,调用tryAcquire(int)
直到成功。 该方法可用于实现方法Lock.lock()
。- 参数
-
arg
- 获取的论据。 该值传达给tryAcquire(int)
,否则无法解释,可以代表您喜欢的任何内容。
-
acquireInterruptibly
public final void acquireInterruptibly(int arg) throws InterruptedException
以独占方式获得,如果中断,中止。 通过首先检查中断状态,然后调用至少一次tryAcquire(int)
,成功返回。 否则线程排队,可能会重复阻塞和解除阻塞,调用tryAcquire(int)
直到成功或线程中断。 该方法可以用于实现方法Lock.lockInterruptibly()
。- 参数
-
arg
- 获取的论据。 该值传达到tryAcquire(int)
,否则无法解释,可以代表您喜欢的任何内容。 - 异常
-
InterruptedException
- 当前线程是否中断
-
tryAcquireNanos
public final boolean tryAcquireNanos(int arg, long nanosTimeout) throws InterruptedException
尝试以独占模式获取,如果中断则中止,如果给定的超时时间失败。 通过首先检查中断状态,然后调用至少一次tryAcquire(int)
,成功返回。 否则,线程排队,可能会重复阻塞和解除阻塞,调用tryAcquire(int)
直到成功或线程中断或超时。 该方法可用于实现方法Lock.tryLock(long, TimeUnit)
。- 参数
-
arg
- 获取的论据。 该值传送到tryAcquire(int)
,否则将被解释,并可以代表您喜欢的任何内容。 -
nanosTimeout
- 要等待的最大纳秒数 - 结果
-
true
如果获得;false
如果超时 - 异常
-
InterruptedException
- 当前线程是否中断
-
release
public final boolean release(int arg)
- 参数
-
arg
- 释放参数。 该值传达给tryRelease(int)
,否则将被解释,并可以代表您喜欢的任何内容。 - 结果
-
该值从
tryRelease(int)
返回
-
acquireShared
public final void acquireShared(int arg)
以共享模式获取,忽略中断。 通过首次调用至少一次执行tryAcquireShared(int)
,成功返回。 否则线程排队,可能会重复阻塞和解除阻塞,直到成功才调用tryAcquireShared(int)
。- 参数
-
arg
- 获取的论据。 该值传达到tryAcquireShared(int)
,否则将被解释,并可以表示任何您喜欢的。
-
acquireSharedInterruptibly
public final void acquireSharedInterruptibly(int arg) throws InterruptedException
以共享方式获取,如果中断,中止。 通过首先检查中断状态,然后至少调用一次tryAcquireShared(int)
,成功返回。 否则线程排队,可能会重复阻塞和解除阻塞,调用tryAcquireShared(int)
直到成功或线程中断。- 参数
-
arg
- 获取的论据。 该值传达给tryAcquireShared(int)
,否则将被解释,可以代表您喜欢的任何内容。 - 异常
-
InterruptedException
- 当前线程是否中断
-
tryAcquireSharedNanos
public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout) throws InterruptedException
尝试以共享模式获取,如果中断则中止,如果给定的时间超过,则失败。 通过首先检查中断状态,然后至少调用一次tryAcquireShared(int)
,成功返回。 否则,线程排队,可能会重复阻塞和解除阻塞,调用tryAcquireShared(int)
直到成功或线程中断或超时。- 参数
-
arg
- 获取的论据。 该值被传送到tryAcquireShared(int)
,否则将被解释并且可以表示任何你喜欢的。 -
nanosTimeout
- 要等待的最大纳秒数 - 结果
-
true
如果获得;false
如果超时 - 异常
-
InterruptedException
- 当前线程是否中断
-
releaseShared
public final boolean releaseShared(int arg)
以共享模式发布。 如果tryReleaseShared(int)
返回true,则通过解除阻塞一个或多个线程来实现。- 参数
-
arg
- 释放参数。 该值传达到tryReleaseShared(int)
,否则将被无法解释,可以代表您喜欢的任何内容。 - 结果
-
该值从
tryReleaseShared(int)
返回
-
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(int)
方法应该返回false
,其tryAcquireShared(int)
方法应该返回一个负值,如果这个方法返回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"
取决于队列是否为空。
-
owns
public final boolean owns(AbstractQueuedSynchronizer.ConditionObject condition)
查询给定的ConditionObject是否将此同步器用作其锁。- 参数
-
condition
- 条件 - 结果
-
true
如果拥有 - 异常
-
NullPointerException
- 如果条件为空
-
hasWaiters
public final boolean hasWaiters(AbstractQueuedSynchronizer.ConditionObject condition)
查询任何线程是否等待与此同步器相关联的给定条件。 请注意,由于超时和中断可能随时发生,因此true
返回不能保证未来的signal
将唤醒任何线程。 该方法主要用于监视系统状态。- 参数
-
condition
- 条件 - 结果
-
true
如果有任何等待线程 - 异常
-
IllegalMonitorStateException
- 如果不保留独占同步 -
IllegalArgumentException
- 如果给定的条件与该同步器没有关联 -
NullPointerException
- 条件为空
-
getWaitQueueLength
public final int getWaitQueueLength(AbstractQueuedSynchronizer.ConditionObject condition)
返回等待与此同步器相关联的给定条件的线程数量的估计。 请注意,由于超时和中断可能在任何时间发生,估计仅作为实际服务员人数的上限。 该方法设计用于监控系统状态,不用于同步控制。- 参数
-
condition
- 条件 - 结果
- 估计等待线程数
- 异常
-
IllegalMonitorStateException
- 如果不保留独占同步 -
IllegalArgumentException
- 如果给定的条件与该同步器没有关联 -
NullPointerException
- 如果条件为空
-
getWaitingThreads
public final Collection<Thread> getWaitingThreads(AbstractQueuedSynchronizer.ConditionObject condition)
返回一个集合,其中包含可能正在等待与此同步器相关联的给定条件的线程。 因为在构建此结果时,实际的线程集可能会动态更改,所以返回的集合只是尽力而为的估计。 返回的集合的元素没有特定的顺序。- 参数
-
condition
- 条件 - 结果
- 线程的收集
- 异常
-
IllegalMonitorStateException
- 如果不保留独占同步 -
IllegalArgumentException
- 如果给定的条件与此同步器没有关联 -
NullPointerException
- 如果条件为空
-
-