Class WaitQueue
- java.lang.Object
-
- org.apache.cassandra.utils.concurrent.WaitQueue
-
public final class WaitQueue extends java.lang.Object
A relatively easy to use utility for general purpose thread signalling.
Usage on a thread awaiting a state change using a WaitQueue q is:
while (!conditionMet()) Signal s = q.register(); if (!conditionMet()) // or, perhaps more correctly, !conditionChanged() s.await(); else s.cancel();
To understand intuitively how this class works, the idea is simply that a thread, once it considers itself incapable of making progress, registers to be awoken once that changes. Since this could have changed between checking and registering (in which case the thread that made this change would have been unable to signal it), it checks the condition again, sleeping only if it hasn't changed/still is not met.
This thread synchronisation scheme has some advantages over Condition objects and Object.wait/notify in that no monitor acquisition is necessary and, in fact, besides the actual waiting on a signal, all operations are non-blocking. As a result consumers can never block producers, nor each other, or vice versa, from making progress. Threads that are signalled are also put into a RUNNABLE state almost simultaneously, so they can all immediately make progress without having to serially acquire the monitor/lock, reducing scheduler delay incurred.
A few notes on utilisation:
1. A thread will only exit await() when it has been signalled, but this does not guarantee the condition has not been altered since it was signalled, and depending on your design it is likely the outer condition will need to be checked in a loop, though this is not always the case.
2. Each signal is single use, so must be re-registered after each await(). This is true even if it times out.
3. If you choose not to wait on the signal (because the condition has been met before you waited on it) you must cancel() the signal if the signalling thread uses signal() to awake waiters; otherwise signals will be lost. If signalAll() is used but infrequent, and register() is frequent, cancel() should still be used to prevent the queue growing unboundedly. Similarly, if you provide a TimerContext, cancel should be used to ensure it is not erroneously counted towards wait time.
4. Care must be taken when selecting conditionMet() to ensure we are waiting on the condition that actually indicates progress is possible. In some complex cases it may be tempting to wait on a condition that is only indicative of local progress, not progress on the task we are aiming to complete, and a race may leave us waiting for a condition to be met that we no longer need.
5. This scheme is not fair
6. Only the thread that calls register() may call await()
-
-
Nested Class Summary
Nested Classes Modifier and Type Class Description static class
WaitQueue.AbstractSignal
An abstract signal implementationstatic interface
WaitQueue.Signal
A Signal is a one-time-use mechanism for a thread to wait for notification that some condition state has transitioned that it may be interested in (and hence should check if it is).
-
Constructor Summary
Constructors Constructor Description WaitQueue()
-
Method Summary
All Methods Static Methods Instance Methods Concrete Methods Modifier and Type Method Description static WaitQueue.Signal
all(WaitQueue.Signal... signals)
static WaitQueue.Signal
any(WaitQueue.Signal... signals)
int
getWaiting()
Return how many threads are waitingboolean
hasWaiters()
WaitQueue.Signal
register()
The calling thread MUST be the thread that uses the signalWaitQueue.Signal
register(com.codahale.metrics.Timer.Context context)
The calling thread MUST be the thread that uses the signal.boolean
signal()
Signal one waiting threadvoid
signalAll()
Signal all waiting threadsstatic void
waitOnCondition(java.util.function.BooleanSupplier condition, WaitQueue queue)
Loops waiting on the supplied condition and WaitQueue and will not return until the condition is true
-
-
-
Method Detail
-
register
public WaitQueue.Signal register()
The calling thread MUST be the thread that uses the signal- Returns:
- x
-
register
public WaitQueue.Signal register(com.codahale.metrics.Timer.Context context)
The calling thread MUST be the thread that uses the signal. If the Signal is waited on, context.stop() will be called when the wait times out, the Signal is signalled, or the waiting thread is interrupted.- Returns:
-
signal
public boolean signal()
Signal one waiting thread
-
signalAll
public void signalAll()
Signal all waiting threads
-
hasWaiters
public boolean hasWaiters()
-
getWaiting
public int getWaiting()
Return how many threads are waiting- Returns:
-
any
public static WaitQueue.Signal any(WaitQueue.Signal... signals)
- Parameters:
signals
-- Returns:
- a signal that returns only when any of the provided signals would have returned
-
all
public static WaitQueue.Signal all(WaitQueue.Signal... signals)
- Parameters:
signals
-- Returns:
- a signal that returns only when all provided signals would have returned
-
waitOnCondition
public static void waitOnCondition(java.util.function.BooleanSupplier condition, WaitQueue queue)
Loops waiting on the supplied condition and WaitQueue and will not return until the condition is true
-
-