Is a HashMap thread-safe for different keys?

If I have two multiple threads accessing a HashMap, but guarantee that they'll never be accessing the same key at the same time, could that still lead to a race condition?

In @dotsid's answer he says this:

If you change a HashMap in any way then your code is simply broken.

He is correct. A HashMap is not thread-safe by design. If it is updated without proper synchronization it may break, even if the threads are using disjoint sets of keys¹. Here are just some² of the things that can go wrong.

• If one thread does a put, then another thread may see a stale value for the hashmap's size.

• If one thread does a put with a key that is (currently) in the same hash bucket as the second thread's key, second thread's map entry might get lost, temporarily or permanently. (This could lead to a get unexpectedly returning null, or other behavior.) It depends on how the hash chains (or whatever) are implemented.

• When a thread does a put that triggers a rebuild of the table, another thread may see transient or stale versions of the hashtable array reference, its size, its contents or the hash chains. Chaos may ensue.

• When a thread does a put for a key that collides with some key used by some other thread, and the latter thread does a put for its key, then the latter might see a stale copy of hash chain reference. Chaos may ensue.

• When one thread probes the table with a key that collides with one of some other thread's keys, it may encounter that key on the chain. It will call equals on that key, and if the threads are not synchronized, the equals method may encounter stale state in that key.

And if you have two threads simultaneously doing get requests and put or remove requests, there are numerous opportunities for race conditions at the application level as described in this answer.

I can think of three solutions:

• Use a ConcurrentHashMap.
• Use a regular HashMap but use external synchronization using primitive mutexes, Lock objects, and so on. But beware that this can lead to a concurrency bottleneck due to lock contention.
• Use a different HashMap for each thread. If the threads really have disjoint sets of keys, then there should be no need (from an algorithmic perspective) for them to share a single Map. Indeed, if your algorithms involve the threads iterating the keys, values or entries of the map at some point, splitting the single map into multiple maps could give a significant speedup for that part of the processing.

^{1 - Even though the key sets are disjoint, keys from one set will at some point end up on the same hash chain as keys from another set. This is unavoidable.
2 - We cannot enumerate all of the possible things that could go wrong. For a start, we can't predict how all JVMs will handle the unspecified aspects of the JMM ... on all platforms. But you should NOT be relying on that kind of information anyway. All you need to know is that it is fundamentally wrong to use a HashMap like this. An application that does this is broken ... even if you haven't observed the symptoms of the brokenness yet.}