java.lang.Objectjava.util.concurrent.locks.AbstractOwnableSynchronizer
java.util.concurrent.locks.AbstractQueuedLongSynchronizer
public abstract class AbstractQueuedLongSynchronizer
A version of 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.
Nested Class Summary | |
---|---|
class |
AbstractQueuedLongSynchronizer.ConditionObject
Condition implementation for a AbstractQueuedLongSynchronizer serving as the basis of a Lock implementation. |
Constructor Summary | |
---|---|
protected |
AbstractQueuedLongSynchronizer()
Creates a new AbstractQueuedLongSynchronizer instance with initial synchronization state of zero. |
Method Summary | |
---|---|
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 |
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. |
Methods inherited from class java.util.concurrent.locks.AbstractOwnableSynchronizer |
---|
getExclusiveOwnerThread, setExclusiveOwnerThread |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait |
Constructor Detail |
---|
protected AbstractQueuedLongSynchronizer()
Method Detail |
---|
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 value
protected 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.
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.
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.
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 shared mode is not supportedprotected boolean isHeldExclusively()
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.
UnsupportedOperationException
- 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 wait
InterruptedException
- 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 wait
InterruptedException
- 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()
In this implementation, this operation returns in constant time.
public final boolean hasContended()
In this implementation, this operation returns in constant time.
public final Thread getFirstQueuedThread()
In this implementation, this operation normally returns in constant time, but may iterate upon contention if other threads are concurrently modifying the queue.
public final boolean isQueued(Thread thread)
This implementation traverses the queue to determine presence of the given thread.
thread
- the thread
NullPointerException
- if thread nullpublic 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()
getState()
, and
either "nonempty" or "empty" depending on
whether the queue is empty.
toString
in class Object
public final boolean owns(AbstractQueuedLongSynchronizer.ConditionObject condition)
condition
- the condition
NullPointerException
- if condition nullpublic final boolean hasWaiters(AbstractQueuedLongSynchronizer.ConditionObject condition)
condition
- the condition
IllegalMonitorStateException
- if exclusive synchronization
is not held
IllegalArgumentException
- if the given condition is
not associated with this synchronizer
NullPointerException
- if condition nullpublic final int getWaitQueueLength(AbstractQueuedLongSynchronizer.ConditionObject condition)
condition
- the condition
IllegalMonitorStateException
- if exclusive synchronization
is not held
IllegalArgumentException
- if the given condition is
not associated with this synchronizer
NullPointerException
- if condition nullpublic final Collection<Thread> getWaitingThreads(AbstractQueuedLongSynchronizer.ConditionObject condition)
condition
- the condition
IllegalMonitorStateException
- if exclusive synchronization
is not held
IllegalArgumentException
- if the given condition is
not associated with this synchronizer
NullPointerException
- if condition null