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
}

• 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

• RWLock

   public RWLock() 

• 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  Index