Methods Summary |
---|
static int | exclusiveCount(int c)Returns the number of exclusive holds represented in count
return c & EXCLUSIVE_MASK;
|
protected java.lang.Thread | getOwner()Returns the thread that currently owns the exclusive lock, or
null if not owned. Note that the owner may be
momentarily null even if there are threads trying to
acquire the lock but have not yet done so. This method is
designed to facilitate construction of subclasses that provide
more extensive lock monitoring facilities.
return sync.getOwner();
|
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 of the system state, not for synchronization
control.
return sync.getQueueLength();
|
protected java.util.Collection | getQueuedReaderThreads()Returns a collection containing threads that may be waiting to
acquire the read lock. 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 lock monitoring facilities.
return sync.getSharedQueuedThreads();
|
protected java.util.Collection | 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.
return sync.getQueuedThreads();
|
protected java.util.Collection | getQueuedWriterThreads()Returns a collection containing threads that may be waiting to
acquire the write lock. 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 lock monitoring facilities.
return sync.getExclusiveQueuedThreads();
|
public int | getReadLockCount()Queries the number of read locks held for this lock. This
method is designed for use in monitoring system state, not for
synchronization control.
return sync.getReadLockCount();
|
public int | getWaitQueueLength(java.util.concurrent.locks.Condition condition)Returns an estimate of the number of threads waiting on the
given condition associated with the write lock. 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 of the system
state, not for synchronization control.
if (condition == null)
throw new NullPointerException();
if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
throw new IllegalArgumentException("not owner");
return sync.getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject)condition);
|
protected java.util.Collection | getWaitingThreads(java.util.concurrent.locks.Condition condition)Returns a collection containing those threads that may be
waiting on the given condition associated with the write lock.
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 condition monitoring facilities.
if (condition == null)
throw new NullPointerException();
if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
throw new IllegalArgumentException("not owner");
return sync.getWaitingThreads((AbstractQueuedSynchronizer.ConditionObject)condition);
|
public int | getWriteHoldCount()Queries the number of reentrant write holds on this lock by the
current thread. A writer thread has a hold on a lock for
each lock action that is not matched by an unlock action.
return sync.getWriteHoldCount();
|
public final boolean | hasQueuedThread(java.lang.Thread thread)Queries whether the given thread is waiting to acquire this
lock. Note that because cancellations may occur at any time, a
true return does not guarantee that this thread
will ever acquire. This method is designed primarily for use
in monitoring of the system state.
return sync.isQueued(thread);
|
public final boolean | hasQueuedThreads()Queries whether any threads are waiting to acquire. Note that
because cancellations may occur at any time, a true
return does not guarantee that any other thread will ever
acquire. This method is designed primarily for use in
monitoring of the system state.
return sync.hasQueuedThreads();
|
public boolean | hasWaiters(java.util.concurrent.locks.Condition condition)Queries whether any threads are waiting on the given condition
associated with the write lock. Note that because timeouts and
interrupts may occur at any time, a true return does
not guarantee that a future signal will awaken any
threads. This method is designed primarily for use in
monitoring of the system state.
if (condition == null)
throw new NullPointerException();
if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
throw new IllegalArgumentException("not owner");
return sync.hasWaiters((AbstractQueuedSynchronizer.ConditionObject)condition);
|
public final boolean | isFair()Returns true if this lock has fairness set true.
return sync instanceof FairSync;
|
public boolean | isWriteLocked()Queries if the write lock is held by any thread. This method is
designed for use in monitoring system state, not for
synchronization control.
return sync.isWriteLocked();
|
public boolean | isWriteLockedByCurrentThread()Queries if the write lock is held by the current thread.
return sync.isHeldExclusively();
|
public java.util.concurrent.locks.ReentrantReadWriteLock$ReadLock | readLock()
return readerLock;
|
static int | sharedCount(int c)Returns the number of shared holds represented in count
return c >>> SHARED_SHIFT;
|
public java.lang.String | toString()Returns a string identifying this lock, as well as its lock state.
The state, in brackets, includes the String "Write locks ="
follwed by the number of reentrantly held write locks, and the
String "Read locks =" followed by the number of held
read locks.
int c = sync.getCount();
int w = exclusiveCount(c);
int r = sharedCount(c);
return super.toString() +
"[Write locks = " + w + ", Read locks = " + r + "]";
|
public java.util.concurrent.locks.ReentrantReadWriteLock$WriteLock | writeLock()
return writerLock;
|