|
Préférences
Moteurs de recherche
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
JavaTM 2 Platform Std. Ed. v1.6.0
java.util.concurrent.locks
|
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.
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
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 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
otherwise
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
true
if acquired; false
if timed out
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
true
if acquired; false
if timed out
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()
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 thread
true
if the given thread is on the queue
NullPointerException
- if the thread is 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()
"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 condition
NullPointerException
- if the condition is 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 the condition is 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 the condition is 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 the condition is null