public abstract class AbstractQueuedLongSynchronizer extends AbstractOwnableSynchronizer implements Serializable
AbstractQueuedSynchronizer
in
which synchronization state is maintained as a long.
This class has exactly the same structure, properties, and methods
as AbstractQueuedSynchronizer with the exception
that all state-related parameters and results are defined
as long rather than int. This class
may be useful when creating synchronizers such as
multilevel locks and barriers that require
64 bits of state.
See AbstractQueuedSynchronizer
for usage
notes and examples.
Modifier and Type | Class and Description |
---|---|
class |
AbstractQueuedLongSynchronizer.ConditionObject
Condition implementation for a
AbstractQueuedLongSynchronizer serving as the basis of a Lock implementation. |
Modifier | Constructor and Description |
---|---|
protected |
AbstractQueuedLongSynchronizer()
Creates a new AbstractQueuedLongSynchronizer instance
with initial synchronization state of zero.
|
Modifier and Type | Method and Description |
---|---|
void |
acquire(long arg)
Acquires in exclusive mode, ignoring interrupts.
|
void |
acquireInterruptibly(long arg)
Acquires in exclusive mode, aborting if interrupted.
|
void |
acquireShared(long arg)
Acquires in shared mode, ignoring interrupts.
|
void |
acquireSharedInterruptibly(long arg)
Acquires in shared mode, aborting if interrupted.
|
protected boolean |
compareAndSetState(long expect,
long update)
Atomically sets synchronization state to the given updated
value if the current state value equals the expected value.
|
Collection<Thread> |
getExclusiveQueuedThreads()
Returns a collection containing threads that may be waiting to
acquire in exclusive mode.
|
Thread |
getFirstQueuedThread()
Returns the first (longest-waiting) thread in the queue, or
null if no threads are currently queued. |
Collection<Thread> |
getQueuedThreads()
Returns a collection containing threads that may be waiting to
acquire.
|
int |
getQueueLength()
Returns an estimate of the number of threads waiting to
acquire.
|
Collection<Thread> |
getSharedQueuedThreads()
Returns a collection containing threads that may be waiting to
acquire in shared mode.
|
protected long |
getState()
Returns the current value of synchronization state.
|
Collection<Thread> |
getWaitingThreads(AbstractQueuedLongSynchronizer.ConditionObject condition)
Returns a collection containing those threads that may be
waiting on the given condition associated with this
synchronizer.
|
int |
getWaitQueueLength(AbstractQueuedLongSynchronizer.ConditionObject condition)
Returns an estimate of the number of threads waiting on the
given condition associated with this synchronizer.
|
boolean |
hasContended()
Queries whether any threads have ever contended to acquire this
synchronizer; that is if an acquire method has ever blocked.
|
boolean |
hasQueuedPredecessors()
Queries whether any threads have been waiting to acquire longer
than the current thread.
|
boolean |
hasQueuedThreads()
Queries whether any threads are waiting to acquire.
|
boolean |
hasWaiters(AbstractQueuedLongSynchronizer.ConditionObject condition)
Queries whether any threads are waiting on the given condition
associated with this synchronizer.
|
protected boolean |
isHeldExclusively()
Returns
true if synchronization is held exclusively with
respect to the current (calling) thread. |
boolean |
isQueued(Thread thread)
Returns true if the given thread is currently queued.
|
boolean |
owns(AbstractQueuedLongSynchronizer.ConditionObject condition)
Queries whether the given ConditionObject
uses this synchronizer as its lock.
|
boolean |
release(long arg)
Releases in exclusive mode.
|
boolean |
releaseShared(long arg)
Releases in shared mode.
|
protected void |
setState(long newState)
Sets the value of synchronization state.
|
String |
toString()
Returns a string identifying this synchronizer, as well as its state.
|
protected boolean |
tryAcquire(long arg)
Attempts to acquire in exclusive mode.
|
boolean |
tryAcquireNanos(long arg,
long nanosTimeout)
Attempts to acquire in exclusive mode, aborting if interrupted,
and failing if the given timeout elapses.
|
protected long |
tryAcquireShared(long arg)
Attempts to acquire in shared mode.
|
boolean |
tryAcquireSharedNanos(long arg,
long nanosTimeout)
Attempts to acquire in shared mode, aborting if interrupted, and
failing if the given timeout elapses.
|
protected boolean |
tryRelease(long arg)
Attempts to set the state to reflect a release in exclusive
mode.
|
protected boolean |
tryReleaseShared(long arg)
Attempts to set the state to reflect a release in shared mode.
|
getExclusiveOwnerThread, setExclusiveOwnerThread
protected AbstractQueuedLongSynchronizer()
protected final long getState()
protected final void setState(long newState)
newState
- the new state valueprotected final boolean compareAndSetState(long expect, long update)
expect
- the expected valueupdate
- the new valueprotected boolean tryAcquire(long arg)
This method is always invoked by the thread performing
acquire. If this method reports failure, the acquire method
may queue the thread, if it is not already queued, until it is
signalled by a release from some other thread. This can be used
to implement method Lock.tryLock()
.
The default
implementation throws UnsupportedOperationException
.
arg
- the acquire argument. This value is always the one
passed to an acquire method, or is the value saved on entry
to a condition wait. The value is otherwise uninterpreted
and can represent anything you like.true
if successful. Upon success, this object has
been acquired.IllegalMonitorStateException
- if acquiring would place this
synchronizer in an illegal state. This exception must be
thrown in a consistent fashion for synchronization to work
correctly.UnsupportedOperationException
- if exclusive mode is not supportedprotected boolean tryRelease(long arg)
This method is always invoked by the thread performing release.
The default implementation throws
UnsupportedOperationException
.
arg
- the release argument. This value is always the one
passed to a release method, or the current state value upon
entry to a condition wait. The value is otherwise
uninterpreted and can represent anything you like.true
if this object is now in a fully released
state, so that any waiting threads may attempt to acquire;
and false
otherwise.IllegalMonitorStateException
- if releasing would place this
synchronizer in an illegal state. This exception must be
thrown in a consistent fashion for synchronization to work
correctly.UnsupportedOperationException
- if exclusive mode is not supportedprotected long tryAcquireShared(long arg)
This method is always invoked by the thread performing acquire. If this method reports failure, the acquire method may queue the thread, if it is not already queued, until it is signalled by a release from some other thread.
The default implementation throws UnsupportedOperationException
.
arg
- the acquire argument. This value is always the one
passed to an acquire method, or is the value saved on entry
to a condition wait. The value is otherwise uninterpreted
and can represent anything you like.IllegalMonitorStateException
- if acquiring would place this
synchronizer in an illegal state. This exception must be
thrown in a consistent fashion for synchronization to work
correctly.UnsupportedOperationException
- if shared mode is not supportedprotected boolean tryReleaseShared(long arg)
This method is always invoked by the thread performing release.
The default implementation throws
UnsupportedOperationException
.
arg
- the release argument. This value is always the one
passed to a release method, or the current state value upon
entry to a condition wait. The value is otherwise
uninterpreted and can represent anything you like.true
if this release of shared mode may permit a
waiting acquire (shared or exclusive) to succeed; and
false
otherwiseIllegalMonitorStateException
- if releasing would place this
synchronizer in an illegal state. This exception must be
thrown in a consistent fashion for synchronization to work
correctly.UnsupportedOperationException
- if shared mode is not supportedprotected boolean isHeldExclusively()
true
if synchronization is held exclusively with
respect to the current (calling) thread. This method is invoked
upon each call to a non-waiting AbstractQueuedLongSynchronizer.ConditionObject
method.
(Waiting methods instead invoke release(long)
.)
The default implementation throws UnsupportedOperationException
. This method is invoked
internally only within AbstractQueuedLongSynchronizer.ConditionObject
methods, so need
not be defined if conditions are not used.
true
if synchronization is held exclusively;
false
otherwiseUnsupportedOperationException
- if conditions are not supportedpublic final void acquire(long arg)
tryAcquire(long)
,
returning on success. Otherwise the thread is queued, possibly
repeatedly blocking and unblocking, invoking tryAcquire(long)
until success. This method can be used
to implement method Lock.lock()
.arg
- the acquire argument. This value is conveyed to
tryAcquire(long)
but is otherwise uninterpreted and
can represent anything you like.public final void acquireInterruptibly(long arg) throws InterruptedException
tryAcquire(long)
, returning on
success. Otherwise the thread is queued, possibly repeatedly
blocking and unblocking, invoking tryAcquire(long)
until success or the thread is interrupted. This method can be
used to implement method Lock.lockInterruptibly()
.arg
- the acquire argument. This value is conveyed to
tryAcquire(long)
but is otherwise uninterpreted and
can represent anything you like.InterruptedException
- if the current thread is interruptedpublic final boolean tryAcquireNanos(long arg, long nanosTimeout) throws InterruptedException
tryAcquire(long)
, returning on success. Otherwise, the thread is
queued, possibly repeatedly blocking and unblocking, invoking
tryAcquire(long)
until success or the thread is interrupted
or the timeout elapses. This method can be used to implement
method Lock.tryLock(long, TimeUnit)
.arg
- the acquire argument. This value is conveyed to
tryAcquire(long)
but is otherwise uninterpreted and
can represent anything you like.nanosTimeout
- the maximum number of nanoseconds to waittrue
if acquired; false
if timed outInterruptedException
- if the current thread is interruptedpublic final boolean release(long arg)
tryRelease(long)
returns true.
This method can be used to implement method Lock.unlock()
.arg
- the release argument. This value is conveyed to
tryRelease(long)
but is otherwise uninterpreted and
can represent anything you like.tryRelease(long)
public final void acquireShared(long arg)
tryAcquireShared(long)
,
returning on success. Otherwise the thread is queued, possibly
repeatedly blocking and unblocking, invoking tryAcquireShared(long)
until success.arg
- the acquire argument. This value is conveyed to
tryAcquireShared(long)
but is otherwise uninterpreted
and can represent anything you like.public final void acquireSharedInterruptibly(long arg) throws InterruptedException
tryAcquireShared(long)
, returning on success. Otherwise the
thread is queued, possibly repeatedly blocking and unblocking,
invoking tryAcquireShared(long)
until success or the thread
is interrupted.arg
- the acquire argument
This value is conveyed to tryAcquireShared(long)
but is
otherwise uninterpreted and can represent anything
you like.InterruptedException
- if the current thread is interruptedpublic final boolean tryAcquireSharedNanos(long arg, long nanosTimeout) throws InterruptedException
tryAcquireShared(long)
, returning on success. Otherwise, the
thread is queued, possibly repeatedly blocking and unblocking,
invoking tryAcquireShared(long)
until success or the thread
is interrupted or the timeout elapses.arg
- the acquire argument. This value is conveyed to
tryAcquireShared(long)
but is otherwise uninterpreted
and can represent anything you like.nanosTimeout
- the maximum number of nanoseconds to waittrue
if acquired; false
if timed outInterruptedException
- if the current thread is interruptedpublic final boolean releaseShared(long arg)
tryReleaseShared(long)
returns true.arg
- the release argument. This value is conveyed to
tryReleaseShared(long)
but is otherwise uninterpreted
and can represent anything you like.tryReleaseShared(long)
public final boolean hasQueuedThreads()
true
return does not guarantee that any
other thread will ever acquire.
In this implementation, this operation returns in constant time.
true
if there may be other threads waiting to acquirepublic final boolean hasContended()
In this implementation, this operation returns in constant time.
true
if there has ever been contentionpublic final Thread getFirstQueuedThread()
null
if no threads are currently queued.
In this implementation, this operation normally returns in constant time, but may iterate upon contention if other threads are concurrently modifying the queue.
null
if no threads are currently queuedpublic final boolean isQueued(Thread thread)
This implementation traverses the queue to determine presence of the given thread.
thread
- the threadtrue
if the given thread is on the queueNullPointerException
- if the thread is nullpublic final boolean hasQueuedPredecessors()
An invocation of this method is equivalent to (but may be more efficient than):
getFirstQueuedThread() != Thread.currentThread() &&
hasQueuedThreads()
Note that because cancellations due to interrupts and
timeouts may occur at any time, a true
return does not
guarantee that some other thread will acquire before the current
thread. Likewise, it is possible for another thread to win a
race to enqueue after this method has returned false
,
due to the queue being empty.
This method is designed to be used by a fair synchronizer to
avoid barging.
Such a synchronizer's tryAcquire(long)
method should return
false
, and its tryAcquireShared(long)
method should
return a negative value, if this method returns true
(unless this is a reentrant acquire). For example, the tryAcquire
method for a fair, reentrant, exclusive mode
synchronizer might look like this:
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
if there is a queued thread preceding the
current thread, and false
if the current thread
is at the head of the queue or the queue is emptypublic final int getQueueLength()
public final Collection<Thread> getQueuedThreads()
public final Collection<Thread> getExclusiveQueuedThreads()
getQueuedThreads()
except that it only returns
those threads waiting due to an exclusive acquire.public final Collection<Thread> getSharedQueuedThreads()
getQueuedThreads()
except that it only returns
those threads waiting due to a shared acquire.public String toString()
"State ="
followed by the current value of getState()
, and either
"nonempty"
or "empty"
depending on whether the
queue is empty.public final boolean owns(AbstractQueuedLongSynchronizer.ConditionObject condition)
condition
- the conditionNullPointerException
- if the condition is nullpublic final boolean hasWaiters(AbstractQueuedLongSynchronizer.ConditionObject condition)
condition
- the conditionIllegalMonitorStateException
- if exclusive synchronization
is not heldIllegalArgumentException
- if the given condition is
not associated with this synchronizerNullPointerException
- if the condition is nullpublic final int getWaitQueueLength(AbstractQueuedLongSynchronizer.ConditionObject condition)
condition
- the conditionIllegalMonitorStateException
- if exclusive synchronization
is not heldIllegalArgumentException
- if the given condition is
not associated with this synchronizerNullPointerException
- if the condition is nullpublic final Collection<Thread> getWaitingThreads(AbstractQueuedLongSynchronizer.ConditionObject condition)
condition
- the conditionIllegalMonitorStateException
- if exclusive synchronization
is not heldIllegalArgumentException
- if the given condition is
not associated with this synchronizerNullPointerException
- if the condition is null Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.