Class ICURWLock

java.lang.Object
com.ibm.icu.impl.ICURWLock

public class ICURWLock extends 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.

  • Field Details

  • Constructor Details

    • ICURWLock

      public ICURWLock()
  • Method Details

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