Mastering Java’s ConcurrentMap: Thread‑Safe Maps Explained

Java ConcurrentMap Interface

Learn how Java’s ConcurrentMap delivers thread‑safe map operations, its core methods, and a hands‑on example using ConcurrentHashMap.

The ConcurrentMap interface extends java.util.Map and provides a highly concurrent, thread‑safe implementation of a map. It guarantees that multiple threads can perform read, write, and update operations simultaneously without corrupting the map’s internal state.

Because ConcurrentMap is an interface, you cannot instantiate it directly. The most common implementation is java.util.concurrent.ConcurrentHashMap, which offers lock‑free reads and fine‑grained locking for updates.

Classes that Implement ConcurrentMap

Although ConcurrentMap itself cannot be instantiated, you can create a concrete map by using one of its implementations. The de‑facto standard is ConcurrentHashMap, but alternatives such as ConcurrentSkipListMap exist for sorted map requirements.

Using ConcurrentMap

First, import the interface:

import java.util.concurrent.ConcurrentMap;

Then create an instance of ConcurrentHashMap:

ConcurrentMap<String, Integer> numbers = new ConcurrentHashMap<>();

In this example, numbers is a thread‑safe map where each String key is paired with an Integer value.

Key concepts:

• Key – a unique identifier that maps to a value.
• Value – the data associated with a key.

Key Methods of ConcurrentMap

In addition to all standard Map operations, ConcurrentMap introduces several atomic, lock‑free methods:

• putIfAbsent(K key, V value) – Adds the key/value pair only if the key is not already present.
• compute(K key, BiFunction) – Atomically updates the value for the specified key based on its current value.
• computeIfAbsent(K key, Function) – Generates a value for a missing key using a supplied function.
• computeIfPresent(K key, BiFunction) – Updates the value of an existing key atomically.
• forEach(BiConsumer) – Performs the given action for each entry.
• merge(K key, V value, BiFunction) – Combines the new value with the existing value using the provided function.

For an in‑depth reference, see the official Java documentation.

Using ConcurrentHashMap with ConcurrentMap

import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ConcurrentHashMap;

public class Main {
    public static void main(String[] args) {
        // Create a thread‑safe map
        ConcurrentMap<String, Integer> numbers = new ConcurrentHashMap<>();

        // Insert elements
        numbers.put("Two", 2);
        numbers.put("One", 1);
        numbers.put("Three", 3);
        System.out.println("ConcurrentMap: " + numbers);

        // Retrieve a value
        int value = numbers.get("One");
        System.out.println("Accessed Value: " + value);

        // Remove a key/value pair
        int removed = numbers.remove("Two");
        System.out.println("Removed Value: " + removed);
    }
}

Output

ConcurrentMap: {One=1, Two=2, Three=3}
Accessed Value: 1
Removed Value: 2

For more advanced usage, consult the ConcurrentHashMap documentation.