Thread safe object cache

Question

The case:
I have a case where I hold configuration about a web page in an xml-file. The configuration is cached in memory on first request then I retrieve the configuration from memory on every following request. If the configuration in the xml-file changes between requests I will release the current configuration from memory and renew it by reading from the file.
Since we are talking about http requests all this will happen in a heavy loaded multithreaded environment.
The current solution:
+public class ConfigFile {+
private static final ConfigCache REGISTRY;
+static {+
REGISTRY = ModuleRegistry.create();
+}+
+public static Element getConfigElement(final String configKey) {+
Element configElm = null;
+if(configFileIsChanged()) {+
REGISTRY.clear();
+}+
+if((configElm = REGISTRY.get(configKey)) == null) {+
+... //Reload configuration from xml-file+
REGISTRY.put(configKey, configElm);//and save to registry
+}+
return configElm;//Return config data as an xml-element
+}+
+... //Class impl..+
+//This inner class holds the configuration as dom element parts+
+private static class ConfigCache {+
+private HashMap<String, Element> _moduleRegistry;+
+public synchronized void put(final String key, final Element elm) {+
_moduleRegistry.put(key, elm);+
+}+
+public synchronized Element get(final String module) {+
+return _moduleRegistry.get(key);+
+}+
+public synchronized void clear() {+
_moduleRegistry.clear();+
+}+
+public static ConfigCache create(){+
return new ConfigCache();
+}+
+}+
+}+
Since the registry is declared as a class variable in the ConfigFile class I handle the put and get operations to it by synchronizing the access.
The problem/question:
Is if this is enough to handle possible threading issues when it comes to invalidating the registry. What happens if some thread tries to "get" from the registry when another just cleared it? I guess it needs to wait until it's reloaded, right?
Regards
Johannes

Answer 1

I wasn't clear enough in my previous post. Sorry for that.
The code will be executed in a servlet/JSP environment but it's not really relevant in this case except for the fact that there will be multiple threads accessing this code.
Think of it as an in memory data storage with information that will be read from the memory. The memory in this case is implemented as a static HashMap (the ConfigCache). I've wrapped it in the ConfigCache class since I want to synchronize the access to the put and get. All threads have access to the configuration file through the static method call ConfigFile.getModuleElement(somElementName);. This method is not synchronized.
Suppose we have 20 threads accessing this code concurrently. I'm not sure how the code will behave when this executes. My guess is that the critical parts are when one thread clears the HashMap, another tries to put something to the Map and another tries to get something.
I made an assertation test where I expected different results from 5 randomly executed web requests with 20 active threads reading and writing to the Map (the ConfigCache). It succeeds but I'm still not sure if I'm on the right track.
I've read a lot about this but I have not found any material describing this as clearly as I want it. In most cases they only explain how to use synchronized blocks and methods.
Are you with me or do you still think this belong in the servlet forum? Maybe it does?
BTW. How do I use code tags?