Class ICURWLock


  • public class ICURWLock
    extends java.lang.Object

    A Reader/Writer lock originally written for ICU service implementation. The internal implementation was replaced with the JDK's stock read write lock (ReentrantReadWriteLock) for ICU 52.

    This assumes that there will be little writing contention. It also doesn't allow active readers to acquire and release a write lock, or deal with priority inversion issues.

    Access to the lock should be enclosed in a try/finally block in order to ensure that the lock is always released in case of exceptions:

     try {
         lock.acquireRead();
         // use service protected by the lock
     }
     finally {
         lock.releaseRead();
     }
     

    The lock provides utility methods getStats and clearStats to return statistics on the use of the lock.

    • Nested Class Summary

      Nested Classes 
      Modifier and Type Class Description
      static class  ICURWLock.Stats
      Internal class used to gather statistics on the RWLock.
    • Field Summary

      Fields 
      Modifier and Type Field Description
      private java.util.concurrent.locks.ReentrantReadWriteLock rwl  
      private ICURWLock.Stats stats  
    • Constructor Summary

      Constructors 
      Constructor Description
      ICURWLock()  
    • Field Detail

      • rwl

        private java.util.concurrent.locks.ReentrantReadWriteLock rwl
    • Constructor Detail

      • ICURWLock

        public ICURWLock()
    • Method Detail

      • resetStats

        public ICURWLock.Stats resetStats()
        Reset the stats. Returns existing stats, if any.
      • clearStats

        public ICURWLock.Stats clearStats()
        Clear the stats (stop collecting stats). Returns existing stats, if any.
      • getStats

        public ICURWLock.Stats getStats()
        Return a snapshot of the current stats. This does not reset the stats.
      • acquireRead

        public void acquireRead()

        Acquire a read lock, blocking until a read lock is available. Multiple readers can concurrently hold the read lock.

        If there's a writer, or a waiting writer, increment the waiting reader count and block on this. Otherwise increment the active reader count and return. Caller must call releaseRead when done (for example, in a finally block).

      • releaseRead

        public void releaseRead()

        Release a read lock and return. An error will be thrown if a read lock is not currently held.

        If this is the last active reader, notify the oldest waiting writer. Call when finished with work controlled by acquireRead.

      • acquireWrite

        public void acquireWrite()

        Acquire the write lock, blocking until the write lock is available. Only one writer can acquire the write lock, and when held, no readers can acquire the read lock.

        If there are no readers and no waiting writers, mark as having an active writer and return. Otherwise, add a lock to the end of the waiting writer list, and block on it. Caller must call releaseWrite when done (for example, in a finally block).

      • releaseWrite

        public void releaseWrite()

        Release the write lock and return. An error will be thrown if the write lock is not currently held.

        If there are waiting readers, make them all active and notify all of them. Otherwise, notify the oldest waiting writer, if any. Call when finished with work controlled by acquireWrite.