How to Create ConcurrentHashMap in Java: Syntax and Example

To create a thread-safe map in Java, use ConcurrentHashMap from java.util.concurrent. Instantiate it with new ConcurrentHashMap<>() to allow safe concurrent access without external synchronization.

Syntax

The basic syntax to create a ConcurrentHashMap is:

ConcurrentHashMap<KeyType, ValueType> map = new ConcurrentHashMap<>();

Here, KeyType and ValueType are the types of keys and values stored in the map. This map supports safe concurrent access by multiple threads.

java

import java.util.concurrent.ConcurrentHashMap;

public class Main {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
    }
}

Example

This example shows how to create a ConcurrentHashMap, add key-value pairs, and safely retrieve values. It demonstrates thread-safe operations without needing explicit synchronization.

java

import java.util.concurrent.ConcurrentHashMap;

public class Main {
    public static void main(String[] args) {
        ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();

        // Adding entries
        map.put("apple", "fruit");
        map.put("carrot", "vegetable");

        // Retrieving entries
        System.out.println("apple is a " + map.get("apple"));
        System.out.println("carrot is a " + map.get("carrot"));
    }
}

Output

apple is a fruit
carrot is a vegetable

Common Pitfalls

Common mistakes when using ConcurrentHashMap include:

• Using HashMap instead, which is not thread-safe and can cause data corruption.
• Assuming ConcurrentHashMap locks the entire map; it uses finer-grained locking for better concurrency.
• Modifying the map while iterating without using the map's iterator, which can cause ConcurrentModificationException with other map types but not with ConcurrentHashMap.

Always prefer ConcurrentHashMap for concurrent access instead of manually synchronizing a HashMap.

java

import java.util.HashMap;
import java.util.Map;

public class WrongExample {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();

        // This is NOT thread-safe if accessed by multiple threads
        map.put("key", "value");
    }
}

// Correct way:
import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;

public class RightExample {
    public static void main(String[] args) {
        Map<String, String> map = new ConcurrentHashMap<>();
        map.put("key", "value");
    }
}

Quick Reference

ConcurrentHashMap Quick Tips:

• Use new ConcurrentHashMap<>() to create a thread-safe map.
• Supports concurrent reads and updates without locking the whole map.
• Does not allow null keys or values.
• Use methods like putIfAbsent for atomic operations.

Key Takeaways

Use ConcurrentHashMap for thread-safe map operations in Java.

Create it with new ConcurrentHashMap<>() specifying key and value types.

ConcurrentHashMap allows concurrent access without locking the entire map.

Avoid using HashMap in multi-threaded contexts to prevent data issues.

ConcurrentHashMap does not permit null keys or values.