- All Implemented Interfaces:
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.
- Since:
- 1.6
- See Also:
-
Nested Class Summary
Nested ClassesModifier and TypeClassDescriptionclassCondition implementation for aAbstractQueuedLongSynchronizerserving as the basis of aLockimplementation. -
Constructor Summary
Constructors -
Method Summary
Modifier and TypeMethodDescriptionfinal voidacquire(long arg) Acquires in exclusive mode, ignoring interrupts.final voidacquireInterruptibly(long arg) Acquires in exclusive mode, aborting if interrupted.final voidacquireShared(long arg) Acquires in shared mode, ignoring interrupts.final voidacquireSharedInterruptibly(long arg) Acquires in shared mode, aborting if interrupted.protected final booleancompareAndSetState(long expect, long update) Atomically sets synchronization state to the given updated value if the current state value equals the expected value.final Collection<Thread>Returns a collection containing threads that may be waiting to acquire in exclusive mode.final ThreadReturns the first (longest-waiting) thread in the queue, ornullif no threads are currently queued.final Collection<Thread>Returns a collection containing threads that may be waiting to acquire.final intReturns an estimate of the number of threads waiting to acquire.final Collection<Thread>Returns a collection containing threads that may be waiting to acquire in shared mode.protected final longgetState()Returns the current value of synchronization state.final Collection<Thread>Returns a collection containing those threads that may be waiting on the given condition associated with this synchronizer.final intReturns an estimate of the number of threads waiting on the given condition associated with this synchronizer.final booleanQueries whether any threads have ever contended to acquire this synchronizer; that is, if an acquire method has ever blocked.final booleanQueries whether any threads have been waiting to acquire longer than the current thread.final booleanQueries whether any threads are waiting to acquire.final booleanQueries whether any threads are waiting on the given condition associated with this synchronizer.protected booleanReturnstrueif synchronization is held exclusively with respect to the current (calling) thread.final booleanReturns true if the given thread is currently queued.final booleanQueries whether the given ConditionObject uses this synchronizer as its lock.final booleanrelease(long arg) Releases in exclusive mode.final booleanreleaseShared(long arg) Releases in shared mode.protected final voidsetState(long newState) Sets the value of synchronization state.toString()Returns a string identifying this synchronizer, as well as its state.protected booleantryAcquire(long arg) Attempts to acquire in exclusive mode.final booleantryAcquireNanos(long arg, long nanosTimeout) Attempts to acquire in exclusive mode, aborting if interrupted, and failing if the given timeout elapses.protected longtryAcquireShared(long arg) Attempts to acquire in shared mode.final booleantryAcquireSharedNanos(long arg, long nanosTimeout) Attempts to acquire in shared mode, aborting if interrupted, and failing if the given timeout elapses.protected booleantryRelease(long arg) Attempts to set the state to reflect a release in exclusive mode.protected booleantryReleaseShared(long arg) Attempts to set the state to reflect a release in shared mode.Methods declared in class java.util.concurrent.locks.AbstractOwnableSynchronizer
getExclusiveOwnerThread, setExclusiveOwnerThread
-
Constructor Details
-
AbstractQueuedLongSynchronizer
public AbstractQueuedLongSynchronizer()Constructor for subclasses to call.
-
-
Method Details
-
getState
protected final long getState()Returns the current value of synchronization state. This operation has memory semantics of avolatileread.- Returns:
- current state value
-
setState
protected final void setState(long newState) Sets the value of synchronization state. This operation has memory semantics of avolatilewrite.- Parameters:
newState- the new state value
-
compareAndSetState
protected final boolean compareAndSetState(long expect, long update) Atomically sets synchronization state to the given updated value if the current state value equals the expected value. This operation has memory semantics of avolatileread and write.- Parameters:
expect- the expected valueupdate- the new value- Returns:
trueif successful. False return indicates that the actual value was not equal to the expected value.
-
tryAcquire
protected boolean tryAcquire(long arg) Attempts to acquire in exclusive mode. This method should query if the state of the object permits it to be acquired in the exclusive mode, and if so to acquire it.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.- Parameters:
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.- Returns:
trueif successful. Upon success, this object has been acquired.- Throws:
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 supported
-
tryRelease
protected boolean tryRelease(long arg) Attempts to set the state to reflect a release in exclusive mode.This method is always invoked by the thread performing release.
The default implementation throws
UnsupportedOperationException.- Parameters:
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.- Returns:
trueif this object is now in a fully released state, so that any waiting threads may attempt to acquire; andfalseotherwise.- Throws:
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 supported
-
isHeldExclusively
protected boolean isHeldExclusively()Returnstrueif synchronization is held exclusively with respect to the current (calling) thread. This method is invoked upon each call to aAbstractQueuedLongSynchronizer.ConditionObjectmethod.The default implementation throws
UnsupportedOperationException. This method is invoked internally only withinAbstractQueuedLongSynchronizer.ConditionObjectmethods, so need not be defined if conditions are not used.- Returns:
trueif synchronization is held exclusively;falseotherwise- Throws:
UnsupportedOperationException- if conditions are not supported
-
acquire
public final void acquire(long arg) Acquires in exclusive mode, ignoring interrupts. Implemented by invoking at least oncetryAcquire(long), returning on success. Otherwise the thread is queued, possibly repeatedly blocking and unblocking, invokingtryAcquire(long)until success. This method can be used to implement methodLock.lock().- Parameters:
arg- the acquire argument. This value is conveyed totryAcquire(long)but is otherwise uninterpreted and can represent anything you like.
-
acquireInterruptibly
Acquires in exclusive mode, aborting if interrupted. Implemented by first checking interrupt status, then invoking at least oncetryAcquire(long), returning on success. Otherwise the thread is queued, possibly repeatedly blocking and unblocking, invokingtryAcquire(long)until success or the thread is interrupted. This method can be used to implement methodLock.lockInterruptibly().- Parameters:
arg- the acquire argument. This value is conveyed totryAcquire(long)but is otherwise uninterpreted and can represent anything you like.- Throws:
InterruptedException- if the current thread is interrupted
-
tryAcquireNanos
Attempts to acquire in exclusive mode, aborting if interrupted, and failing if the given timeout elapses. Implemented by first checking interrupt status, then invoking at least oncetryAcquire(long), returning on success. Otherwise, the thread is queued, possibly repeatedly blocking and unblocking, invokingtryAcquire(long)until success or the thread is interrupted or the timeout elapses. This method can be used to implement methodLock.tryLock(long, TimeUnit).- Parameters:
arg- the acquire argument. This value is conveyed totryAcquire(long)but is otherwise uninterpreted and can represent anything you like.nanosTimeout- the maximum number of nanoseconds to wait- Returns:
trueif acquired;falseif timed out- Throws:
InterruptedException- if the current thread is interrupted
-
release
public final boolean release(long arg) Releases in exclusive mode. Implemented by unblocking one or more threads iftryRelease(long)returns true. This method can be used to implement methodLock.unlock().- Parameters:
arg- the release argument. This value is conveyed totryRelease(long)but is otherwise uninterpreted and can represent anything you like.- Returns:
- the value returned from
tryRelease(long)
-
hasQueuedThreads
public final boolean hasQueuedThreads()Queries whether any threads are waiting to acquire. Note that because cancellations due to interrupts and timeouts may occur at any time, atruereturn does not guarantee that any other thread will ever acquire.- Returns:
trueif there may be other threads waiting to acquire
-
hasContended
public final boolean hasContended()Queries whether any threads have ever contended to acquire this synchronizer; that is, if an acquire method has ever blocked.In this implementation, this operation returns in constant time.
- Returns:
trueif there has ever been contention
-
getFirstQueuedThread
Returns the first (longest-waiting) thread in the queue, ornullif 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.
- Returns:
- the first (longest-waiting) thread in the queue, or
nullif no threads are currently queued
-
isQueued
Returns true if the given thread is currently queued.This implementation traverses the queue to determine presence of the given thread.
- Parameters:
thread- the thread- Returns:
trueif the given thread is on the queue- Throws:
NullPointerException- if the thread is null
-
hasQueuedPredecessors
public final boolean hasQueuedPredecessors()Queries whether any threads have been waiting to acquire longer than the current thread.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
truereturn 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 returnedfalse, 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 returnfalse, and itstryAcquireShared(long)method should return a negative value, if this method returnstrue(unless this is a reentrant acquire). For example, thetryAcquiremethod for a fair, reentrant, exclusive mode synchronizer might look like this:protected boolean tryAcquire(long arg) { if (isHeldExclusively()) { // A reentrant acquire; increment hold count return true; } else if (hasQueuedPredecessors()) { return false; } else { // try to acquire normally } }- Returns:
trueif there is a queued thread preceding the current thread, andfalseif the current thread is at the head of the queue or the queue is empty- Since:
- 1.7
-
getQueueLength
public final int getQueueLength()Returns an estimate of the number of threads waiting to acquire. The value is only an estimate because the number of threads may change dynamically while this method traverses internal data structures. This method is designed for use in monitoring system state, not for synchronization control.- Returns:
- the estimated number of threads waiting to acquire
-
getQueuedThreads
Returns a collection containing threads that may be waiting to acquire. Because the actual set of threads may change dynamically while constructing this result, the returned collection is only a best-effort estimate. The elements of the returned collection are in no particular order. This method is designed to facilitate construction of subclasses that provide more extensive monitoring facilities.- Returns:
- the collection of threads
-
getExclusiveQueuedThreads
Returns a collection containing threads that may be waiting to acquire in exclusive mode. This has the same properties asgetQueuedThreads()except that it only returns those threads waiting due to an exclusive acquire.- Returns:
- the collection of threads
-
toString
Returns a string identifying this synchronizer, as well as its state. The state, in brackets, includes the String"State ="followed by the current value ofgetState(), and either"nonempty"or"empty"depending on whether the queue is empty. -
owns
Queries whether the given ConditionObject uses this synchronizer as its lock.- Parameters:
condition- the condition- Returns:
trueif owned- Throws:
NullPointerException- if the condition is null
-
hasWaiters
Queries whether any threads are waiting on the given condition associated with this synchronizer. Note that because timeouts and interrupts may occur at any time, atruereturn does not guarantee that a futuresignalwill awaken any threads. This method is designed primarily for use in monitoring of the system state.- Parameters:
condition- the condition- Returns:
trueif there are any waiting threads- Throws:
IllegalMonitorStateException- if exclusive synchronization is not heldIllegalArgumentException- if the given condition is not associated with this synchronizerNullPointerException- if the condition is null
-
getWaitQueueLength
Returns an estimate of the number of threads waiting on the given condition associated with this synchronizer. Note that because timeouts and interrupts may occur at any time, the estimate serves only as an upper bound on the actual number of waiters. This method is designed for use in monitoring system state, not for synchronization control.- Parameters:
condition- the condition- Returns:
- the estimated number of waiting threads
- Throws:
IllegalMonitorStateException- if exclusive synchronization is not heldIllegalArgumentException- if the given condition is not associated with this synchronizerNullPointerException- if the condition is null
-
getWaitingThreads
public final Collection<Thread> getWaitingThreads(AbstractQueuedLongSynchronizer.ConditionObject condition) Returns a collection containing those threads that may be waiting on the given condition associated with this synchronizer. Because the actual set of threads may change dynamically while constructing this result, the returned collection is only a best-effort estimate. The elements of the returned collection are in no particular order.- Parameters:
condition- the condition- Returns:
- the collection of threads
- Throws:
IllegalMonitorStateException- if exclusive synchronization is not heldIllegalArgumentException- if the given condition is not associated with this synchronizerNullPointerException- if the condition is null
-