Difference Between HashMap and ConcurrentHashMap in Java with Examples

HashMap and ConcurrentHashMap are two commonly used implementations of the Map interface in Java. While both store data as key-value pairs, they behave very differently in multi-threaded applications. Understanding these differences is essential for writing thread-safe and high-performance Java applications.

What is HashMap?

HashMap is a non-synchronized implementation of the Map interface. It provides excellent performance in single-threaded environments but is not safe for concurrent access by multiple threads.


Map<Integer, String> map = new HashMap<>();

map.put(1, "Java");
map.put(2, "Spring Boot");

System.out.println(map.get(1));

HashMap allows one null key and multiple null values.

What is ConcurrentHashMap?

ConcurrentHashMap is a thread-safe implementation of the Map interface introduced to support high-performance concurrent operations. Multiple threads can read and update the map simultaneously without causing data corruption.


Map<Integer, String> map = new ConcurrentHashMap<>();

map.put(1, "Java");
map.put(2, "Spring Boot");

System.out.println(map.get(1));

Why Do We Need ConcurrentHashMap?

Suppose multiple threads access a HashMap at the same time and one thread modifies the map while another thread reads it. This may result in inconsistent data and unpredictable behaviour.

ConcurrentHashMap was created to solve these problems while maintaining good performance.

HashMap Example in Multi-Threaded Environment


Map<Integer, String> map = new HashMap<>();

Runnable task = () -> {
    for(int i = 0; i < 1000; i++) {
        map.put(i, "Value " + i);
    }
};

new Thread(task).start();
new Thread(task).start();

The above code may produce inconsistent results because HashMap is not thread-safe.

ConcurrentHashMap Example


Map<Integer, String> map =
        new ConcurrentHashMap<>();

Runnable task = () -> {
    for(int i = 0; i < 1000; i++) {
        map.put(i, "Value " + i);
    }
};

new Thread(task).start();
new Thread(task).start();

ConcurrentHashMap handles concurrent operations safely without corrupting data.

Major Differences Between HashMap and ConcurrentHashMap

Feature	HashMap	ConcurrentHashMap
Thread Safe	No	Yes
Performance	Fast in single thread	Optimized for multiple threads
Null Key	Allowed	Not Allowed
Null Values	Allowed	Not Allowed
Synchronization	Not Synchronized	Internally Managed
Suitable For	Single-threaded applications	Multi-threaded applications

Why ConcurrentHashMap Does Not Allow Null Keys or Values

ConcurrentHashMap does not allow null keys or null values because it becomes difficult to determine whether a null result means that the key does not exist or that the value itself is null.


Map<Integer,String> map =
        new ConcurrentHashMap<>();

map.put(null, "Java");

Output


Exception in thread "main"
java.lang.NullPointerException

How ConcurrentHashMap Achieves Better Performance

In older Java versions, ConcurrentHashMap used segmented locking, allowing multiple threads to work on different segments simultaneously.

In modern Java versions, finer-grained locking and CAS (Compare-And-Swap) operations are used, which significantly improve performance.

Iterating Through ConcurrentHashMap

Unlike HashMap, ConcurrentHashMap supports safe iteration while updates are happening.


ConcurrentHashMap<Integer,String> map =
        new ConcurrentHashMap<>();

map.put(1, "Java");
map.put(2, "Spring");

for(Map.Entry<Integer,String> entry : map.entrySet()) {

    System.out.println(
        entry.getKey() + " : " +
        entry.getValue()
    );
}

When Should You Use HashMap?

Single-threaded applications
Desktop applications
Data processing programs
Situations where synchronization is unnecessary

When Should You Use ConcurrentHashMap?

Multi-threaded applications
Web applications
Microservices
Spring Boot applications
High-concurrency environments

Interview Questions

Can HashMap be used in multi-threaded applications?

HashMap can be used, but it is not thread-safe and may produce inconsistent results.

Does ConcurrentHashMap lock the entire map?

No. ConcurrentHashMap uses advanced concurrency techniques to minimize locking and improve performance.

Can ConcurrentHashMap store null values?

No. Both null keys and null values are prohibited.

Which is faster?

HashMap is generally faster in single-threaded environments. ConcurrentHashMap performs better when multiple threads need simultaneous access.

Best Practices

Use HashMap for single-threaded programs.
Use ConcurrentHashMap for web applications and APIs.
Avoid Hashtable in modern applications.
Never use HashMap for shared mutable data without synchronization.

Conclusion

Both HashMap and ConcurrentHashMap are powerful collection classes in Java. HashMap provides excellent performance for single-threaded applications, whereas ConcurrentHashMap is specifically designed for safe and efficient concurrent access. Choosing the correct implementation can improve both application performance and reliability.

Frequently Asked Questions (FAQ)

Is ConcurrentHashMap thread-safe?

Yes. ConcurrentHashMap is designed for concurrent access by multiple threads.

Can ConcurrentHashMap contain null values?

No. Null keys and null values are not permitted.

Can multiple threads read ConcurrentHashMap simultaneously?

Yes. Multiple threads can safely read data at the same time.

Which map implementation should be used in Spring Boot applications?

ConcurrentHashMap is typically preferred when shared data is accessed by multiple threads.

How HashMap Works Internally in Java

Keywords

HashMap vs ConcurrentHashMap, Difference Between HashMap and ConcurrentHashMap, ConcurrentHashMap Tutorial, Java Concurrent Collections, Java Multithreading Interview Questions, Thread Safe Collections in Java, ConcurrentHashMap Example, HashMap Thread Safety, ConcurrentHashMap Internal Working, Java Concurrency Tutorial, Java Collections Framework, Java Interview Questions, Thread Safe HashMap Alternative, ConcurrentHashMap in Spring Boot, Java Performance Optimization