Is it safe to get values from a java.util.HashMap from multiple threads (no modification)?

concurrency, hashmap, java, multithreading

Solution

Your idiom is safe if and only if the reference to the `HashMap` is safely published. Rather than anything relating the internals of `HashMap` itself, safe publication deals with how the constructing thread makes the reference to the map visible to other threads.

Basically, the only possible race here is between the construction of the `HashMap` and any reading threads that may access it before it is fully constructed. Most of the discussion is about what happens to the state of the map object, but this is irrelevant since you never modify it - so the only interesting part is how the `HashMap` reference is published.

For example, imagine you publish the map like this:

class SomeClass {
   public static HashMap<Object, Object> MAP;

   public synchronized static setMap(HashMap<Object, Object> m) {
     MAP = m;
   }
}

... and at some point `setMap()` is called with a map, and other threads are using `SomeClass.MAP` to access the map, and check for null like this:

HashMap<Object,Object> map = SomeClass.MAP;
if (map != null) {
  .. use the map
} else {
  .. some default behavior
}

This is not safe even though it probably appears as though it is. The problem is that there is no happens-before relationship between the set of `SomeObject.MAP` and the subsequent read on another thread, so the reading thread is free to see a partially constructed map. This can pretty much do anything and even in practice it does things like put the reading thread into an infinite loop.

To safely publish the map, you need to establish a happens-before relationship between the writing of the reference to the `HashMap` (i.e., the publication) and the subsequent readers of that reference (i.e., the consumption). Conveniently, there are only a few easy-to-remember ways to accomplish that[1]:

- Exchange the reference through a properly locked field (JLS 17.4.5)

- Use static initializer to do the initializing stores (JLS 12.4)

- Exchange the reference via a volatile field (JLS 17.4.5), or as the consequence of this rule, via the AtomicX classes

- Initialize the value into a final field (JLS 17.5).

The ones most interesting for your scenario are (2), (3) and (4). In particular, (3) applies directly to the code I have above: if you transform the declaration of `MAP` to:

public static volatile HashMap<Object, Object> MAP;

then everything is kosher: readers who see a non-null value necessarily have a happens-before relationship with the store to `MAP` and hence see all the stores associated with the map initialization.

The other methods change the semantics of your method, since both (2) (using the static initalizer) and (4) (using final) imply that you cannot set `MAP` dynamically at runtime. If you don't need to do that, then just declare `MAP` as a `static final HashMap<>` and you are guaranteed safe publication.

In practice, the rules are simple for safe access to "never-modified objects":

If you are publishing an object which is not inherently immutable (as in all fields declared `final`) and:

- You already can create the object that will be assigned at the moment of declarationa: just use a `final` field (including `static final` for static members).

- You want to assign the object later, after the reference is already visible: use a volatile fieldb.

That's it!

In practice, it is very efficient. The use of a `static final` field, for example, allows the JVM to assume the value is unchanged for the life of the program and optimize it heavily. The use of a `final` member field allows most architectures to read the field in a way equivalent to a normal field read and doesn't inhibit further optimizationsc.

Finally, the use of `volatile` does have some impact: no hardware barrier is needed on many architectures (such as x86, specifically those that don't allow reads to pass reads), but some optimization and reordering may not occur at compile time - but this effect is generally small. In exchange, you actually get more than what you asked for - not only can you safely publish one `HashMap`, you can store as many more not-modified `HashMap`s as you want to the same reference and be assured that all readers will see a safely published map.

For more gory details, refer to Shipilev or this FAQ by Manson and Goetz.

[1] Directly quoting from shipilev.

a That sounds complicated, but what I mean is that you can assign the reference at construction time - either at the declaration point or in the constructor (member fields) or static initializer (static fields).

b Optionally, you can use a `synchronized` method to get/set, or an `AtomicReference` or something, but we're talking about the minimum work you can do.

c Some architectures with very weak memory models (I'm looking at you, Alpha) may require some type of read barrier before a `final` read - but these are very rare today.

Problem

Original source

Related problems

• calling thread.start() within its own constructor
• Safe Publication without happens-before? Anyhow besides final?