Best way to synchronize reads and writes on a map with potential updates on the entire map

So I have this fetcher code that fetches a json configuration which is a map of string to booleans (its a json schema that is guaranteed)

I have to implement this method

private volatile Map<String, Boolean> flags = new HashMap<>();
private volatile String currFlagJson = "";
private final Retriever retriever; // This is initialized elsewhere, but it basically returns a cached json with a separate thread updating it. 

public Optional<Boolean> isFlagEnabled(final String featureFlag) {
   final var json = retriever.retrieve();
   if (!json.equals(currJson.get)) {
       updateMap(json);
       return Optional.ofNullable(flags.get(featureFlag));
   } else {
       return Optional.ofNullable(flags.get(featureFlag));
   }
}

private synchronized updateMap(final String newJson) {
    final var newMap = expensiveJsonParsingOperation(newJson)
    flags = newMap;
    currFlagJson = newJson;
}

I am trying to avoid multiple threads concurrently updating the map, but this I do not think completely works. If multiple threads race and calling the equals method, while one of the threads is updating, then eventually all the threads will try to contend updating it. I could of course synchronize the entirity of isFlagEnabled but that would be unnecessarily locking too and I could be serving read requests while the expensiveJsonParsingOperation is happening.

I am trying to figure out how best to

1. Ensure exactly one thread updates this map when needed.
2. Not block threads on reads while this update is happening.

Maybe. https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/locks/ReentrantReadWriteLock.html? Or something else I can use for this case?

You can use double-checked locking to make sure it only updates once without introducing too much contention between readers:

public Optional<Boolean> isFlagEnabled(final String featureFlag) {
    var json = retriever.retrieve();
    if (!json.equals(currFlagJson)) {
        synchronized (this) {
            if (!json.equals(currFlagJson)) {
                flags = expensiveJsonParsingOperation(newJson);
                currFlagJson = json;
            }
        }
    }
    return Optional.ofNullable(flags.get(featureFlag));
}

Note that there's no need to use a ConcurrentMap if you're only updating the reference without modifying the map itself. If you use an immutable map, you can also omit volatile from flags (relying on the currFlagJson memory barrier to keep the map reference fresh). Otherwise, there's a risk of partial publication if the field is read while another thread is updating it. Either way, currFlagJson must be volatile to ensure it's not cached.