Better solution than while (reentrantLock.isLocked()) for waiting

I have a service bean which provides access to a Map. From time to time I need to rebuild the content of the Map which takes several seconds and I want to block the access to the map while it's rebuilding, because it can be accessed from different Threads.

@Service
public class MyService {
  private Map<Key,Value> cache = null;
  private ReentrantLock reentrantLock = new ReentrantLock();

   public void rebuildCache(){
     try {
       reentrantLock.lock();
       cache = new ConcurrentHashMap<>();
       ... //processing time consuming stuff and building up the cache
       }finally {
        reentrantLock.unlock();
     }
   }
    
   public Value getValue(Key key){
     while (lock.isLocked()){}
     return cache.get(key);
   }
   ...
}

As you can see I use

while (reentrantLock.isLocked()){}

to check if the lock is locked and wait until its unlocked. This solution seems to be quite dirty. Is there a better solution?

Use a ReentrantReadWriteLock instead.

In your write method:

theLock.writeLock().lock();
try {
    // update the map
} finally {
    theLock.writeLock().unlock();

  }

In the read method, use the .readLock() instead.

This has the problem however that during the update of the map, all readers will be blocked; another solution would be to use a plain lock to replace the reference of the old map to a new, updated one, and use a plain old synchronized.

---

More importantly though, your use of locks is incorrect. You should do:

theLock.lock();
try {
    // whatever
} finally {
    theLock.unlock();
}

Imagine what happens if the locking fails with your current lock: you'll always try to unlock and you'll end up with an IllegalLockStateException.