ConcurrentHashMap vs Synchronized HashMap in Java

-

Introduction

In multi-threaded Java applications, managing shared data safely and efficiently is crucial. Two common approaches are using Synchronized HashMap (via Collections.synchronizedMap(...)) and ConcurrentHashMap. While both aim to provide thread-safety, their implementations and performance characteristics differ significantly. This post explores these differences in detail.

What is a Synchronized HashMap?

  • Created by wrapping a regular HashMap using:
    Map<K, V> syncMap = Collections.synchronizedMap(new HashMap<>());
  • Enforces synchronization at the object level, meaning only one thread can access the map at any time (read or write).
  • Supports null keys and values since it relies on HashMap behavior.
  • Iterators are fail-fast, throwing ConcurrentModificationException if the map is modified while iterating.
  • Simpler implementation, suitable when concurrency is low or performance is not critical.

What is ConcurrentHashMap?

  • Introduced in Java 1.5 to provide a scalable thread-safe Map.
  • Uses bucket-level locking (lock striping) instead of locking the entire map.
  • Read operations are non-blocking, and write operations only lock specific buckets, allowing multiple threads to work concurrently.
  • Does not allow null keys or values (insertion of null throws NullPointerException).
  • Iterators are fail-safe (weakly consistent). They do not throw exceptions and can tolerate concurrent modifications.
  • From Java 8 onward:
    • Uses CAS (Compare-And-Swap) for certain operations, making it even more efficient.
    • Introduced tree bins instead of linked lists for buckets with many collisions, improving performance from O(n) to O(log n).
  • Provides atomic methods like putIfAbsent(), remove(), and compute() for safe concurrent updates.

Feature Comparison

Feature Synchronized HashMap ConcurrentHashMap
Synchronization Strategy Whole map (object-level) Bucket/segment level (fine-grained locking)
Read Performance Poor under high contention Excellent (non-blocking)
Write Performance Locks entire map Locks only a bucket
Null Support Allows null keys & values No null keys/values allowed
Iterator Behavior Fail-fast (throws exception) Fail-safe (weakly consistent)
Atomic Operations Not supported Supported (putIfAbsent, compute, etc.)
Best Use Case Low concurrency, simple apps High concurrency, scalable apps

When to Use What?

  • Synchronized HashMap:
    • Best for simple applications with minimal concurrency.
    • Easy to use but can become a bottleneck in multi-threaded systems.
  • ConcurrentHashMap:
    • Ideal for high-performance, concurrent systems.
    • Recommended when frequent read/write operations occur across multiple threads.

Real-World Use Cases

  • Caching in multi-threaded applications.
  • Storing session data in concurrent web applications.
  • Counting word frequency or events in real-time streaming systems.
  • Thread-safe registries like service locators or configuration maps.

Conclusion

Both Synchronized HashMap and ConcurrentHashMap provide thread-safety, but they serve different purposes. If performance and scalability are important in your multi-threaded application, ConcurrentHashMap is the better choice. For simple use cases with limited concurrency, a synchronized wrapper around HashMap may be sufficient.

Comments

Post a Comment

Popular posts from this blog

Spring Boot on AWS EC2: Upload to S3 Securely Using IAM Role

-
When running a Spring Boot application on AWS EC2 , the most common security mistake is hardcoding AWS access keys inside application.properties . This is unnecessary and risky. AWS already provides a secure mechanism: IAM Roles attached to EC2 . In this blog, you will learn how to upload and download files to Amazon S3 from Spring Boot running on EC2 without any access keys , using: Spring Profiles AWS SDK v2 Instance Metadata Service (IMDS) IAM Roles Why Access Keys Are a Bad Idea on EC2 Typical S3 setups use: Access key Secret key Region Bucket This works only for local development. It should NOT be used on EC2. Problems with access keys: Stored in config or code (high risk) Might leak through Git, logs, or screenshots Require manual rotation Not needed if app runs on EC2 AWS automatically manages temporary credentials using the EC2 Instance Profile (IAM Role) . Architecture: EC2 → IAM Role → S3 Spring Boot app r...
Read more

Java Streams Intermediate Operations Explained with Examples

-
Image
The Java Stream API lets you process collections in a fluent, declarative style. In this post, we’ll walk through the most useful intermediate operations with simple examples. Note: Examples below use Java 8 compatible collect(Collectors.toList()) . If you’re on Java 16+, you can replace it with toList() . 1) filter() — Select elements by a condition Keeps only elements that match the predicate. List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10); List<Integer> res = list.stream() .filter(num -> num % 2 != 0) // keep only odd numbers .collect(Collectors.toList()); System.out.println(res); // [1, 3, 5, 7, 9] 2) map() — Transform each element Applies a function to every element and returns a stream of results. List<String> strs = Arrays.asList("rama", "anjaneya", "krishna"); List<String> upper = strs.stream() .map(String::toUpperCase) .collect(Collectors.toList()); System.o...
Read more