All Packages This Package Class Hierarchy Class Search Index
Class calypso.util.RWLock
java.lang.Object | +----calypso.util.RWLock
A "read-write" lock. This lock allows for an arbitrary number of simultaneous readers. The lock can be upgraded to a write lock in two ways. First, the lock can be upgraded without guaranteeing invariance across the transition (in other words, the read lock may need to be released before the write lock can be acquired). The other form of upgrade guarantees invariance; however, the upgrade can only be performed by initially locking the lock using the invariant read lock enter method. Upgrading the lock in either case involves waiting until there are no more readers. This implementation gives priority to upgrades and invariant locks which may lead to reader starvation.
Each thread using the lock may re-enter the lock as many times as needed. However, attempting to re-enter the lock with the invariant read lock will fail unless the lock was originally entered that way by the invoking thread.
Only one thread may enter the invariant read lock at a time; other threads attempting this will block until the owning thread exits the lock completely.
Note that the implementation assumes that the user of instances of this class properly pairs the enters/exits.
public final class RWLock
extends java.lang.Object
{
// Fields 13
private LockState fFreeList;
private int fFreeListLength;
private int fInvariantLockCount;
private Thread fInvariantLockOwner;
private int fNumReaders;
private LockState fStateList;
private int fWriteLockCount;
private Thread fWriteLockOwner;
static final int kInvariantRead;
private static final int kMaxFreeListLength;
static final int kRead;
static String[] kStateToString;
static final int kWrite;
// Constructors 1
public RWLock();
// Methods 11
private void appendLockState(Thread, int);
public synchronized void enterInvariantReadLock() throws InterruptedException;
public synchronized void enterReadLock() throws InterruptedException;
public synchronized void enterWriteLock() throws InterruptedException;
public synchronized void exitInvariantReadLock();
public synchronized void exitReadLock();
public synchronized void exitWriteLock();
private void freeLockState(LockState);
private boolean isLocked(Thread, int);
private LockState newLockState();
private void removeLockState(Thread, int);
// Inner Classes 1
static class LockState
}
Fields
• fNumReaders
private int fNumReaders
• fWriteLockOwner
private Thread fWriteLockOwner
• fWriteLockCount
private int fWriteLockCount
• fInvariantLockOwner
private Thread fInvariantLockOwner
• fInvariantLockCount
private int fInvariantLockCount
• kRead
static final int kRead
• kWrite
static final int kWrite
• kInvariantRead
static final int kInvariantRead
• kStateToString
static String[] kStateToString
• fStateList
private LockState fStateList
Circular list of LockState objects. When the lock changes state (via one of the three enter methods) we append a LockState object to the end of the stack. When a thread exits the lock we find it's last LockState object and remove it from the list.
• fFreeList
private LockState fFreeList
A list of free LockState objects used to reduce the execution time for allocation.
• fFreeListLength
private int fFreeListLength
• kMaxFreeListLength
private static final int kMaxFreeListLength
Constructors
• RWLock
public RWLock()
Methods
• enterReadLock
public synchronized void enterReadLock() throws InterruptedException
• exitReadLock
public synchronized void exitReadLock()
• enterInvariantReadLock
public synchronized void enterInvariantReadLock() throws InterruptedException
Enter the invariant read lock. Only one thread at a time can hold the invariant read lock. This lock guarantees to upgrade to a write lock without needing to release the read lock.
• exitInvariantReadLock
public synchronized void exitInvariantReadLock()
• enterWriteLock
public synchronized void enterWriteLock() throws InterruptedException
• exitWriteLock
public synchronized void exitWriteLock()
• isLocked
private boolean isLocked(Thread aThread, int aHow)
See if aThread has the given type of lock
• appendLockState
private void appendLockState(Thread aThread, int aState)
• removeLockState
private void removeLockState(Thread aThread, int aState)
Walk up the thread state list and look for aThread. Verify that the LockState is in the right state and if it is then we remove that LockState from the list.
• newLockState
private LockState newLockState()
• freeLockState
private void freeLockState(LockState aState)
All Packages This Package Class Hierarchy Class Search IndexFreshly brewed Java API Documentation automatically generated with polardoc Version 1.0.4