Midpoint Midpoint - 21 days ago 7
Java Question

In Java, is it safe to change a reference to a HashMap read concurrently

I hope this isn't too silly a question...

I have code similar to the following in my project:

public class ConfigStore {

public static class Config {

public final String setting1;
public final String setting2;
public final String setting3;

public Config(String setting1, String setting2, String setting3) {
this.setting1 = setting1;
this.setting2 = setting2;
this.setting3 = setting3;
}

}

private volatile HashMap<String, Config> store = new HashMap<String, Config>();

public void swapConfigs(HashMap<String, Config> newConfigs) {
this.store = newConfigs;
}

public Config getConfig(String name) {
return this.store.get(name);
}

}


As requests are processed, each thread will request a config to use from the store using the getConfig() function. However, periodically (every few days most likely), the configs are updated and swapped out using the swapConfigs() function. The code that calls swapConfigs() does not keep a reference to the Map it passes in as it is simply the result of parsing a configuration file.


  • In this case, is the
    volatile
    keyword still needed on the store instance variable?

  • Will the
    volatile
    keyword introduce any potential performance bottlenecks that I should be aware of or can avoid given that the rate of reads greatly exceeds the rate of writes?



Thanks very much,

Answer

Since changing references is an atomic operation, you won't end up with one thread modifying the reference, and the other seeing a garbage reference, even if you drop volatile. However, the new map may not get instantly visible for some threads, which may consequently keep reading configuration from the old map for an indefinite time (or forever). So keep volatile.

Update

As @BeeOnRope pointed out in a comment below, there is an even stronger reason to use volatile:

"non-volatile writes [...] don't establish a happens-before relationship between the write and subsequent reads that see the written value. This means that a thread can see a new map published through the instance variable, but this new map hasn't been fully constructed yet. This is not intuitive, but it's a consequence of the memory model, and it happens in the real word. For an object to be safely published, it must be written to a volatile, or use a handful of other techniques.

Since you change the value very rarely, I don't think volatile would cause any noticeable performance difference. But at any rate, correct behaviour trumps performance.

Comments