Microsoft007: HashMap vs SynchronizedMap vs ConcurrentHashMap in Java

🔍 1)What is a `HashMap`?

A HashMap is a part of the Java Collection Framework that stores data in key-value pairs using a hash table.

📦 Package: java.util.HashMap
🔑 Keys must be unique
❗ Allows one null key and multiple null values

🧠 How Does It Work?

Internally uses an array of buckets (array of Node<K,V>).
Each key’s hashCode() is used to find a bucket index.
If two keys have the same hash, a linked list or balanced tree (Java 8+) is used in that bucket (called collision handling).

📌 Key Characteristics

Feature	Description
Thread-safe	❌ Not thread-safe
Allows null key	✅ Only one `null` key
Allows null values	✅ Any number of `null` values
Order maintained	❌ No (use `LinkedHashMap` if needed)
Performance	⚡ Fast `O(1)` for get/put in average case
Load Factor (default)	`0.75` (when to resize)
Initial Capacity (default)	`16`

✅ Example – Basic Usage

import java.util.HashMap;

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

        map.put(1, "Apple");
        map.put(2, "Banana");
        map.put(null, "NullKey");
        map.put(3, null); // null value allowed

        System.out.println(map.get(1));     // Apple
        System.out.println(map.get(null));  // NullKey
        System.out.println(map);            // {null=NullKey, 1=Apple, 2=Banana, 3=null}
    }
}

🔧 Common Methods

Method	Description
`put(K, V)`	Add/update a key-value pair
`get(K)`	Get value by key
`remove(K)`	Remove key
`containsKey(K)`	Check if key exists
`containsValue(V)`	Check if value exists
`keySet()`	Returns set of keys
`values()`	Returns collection of values
`entrySet()`	Returns set of key-value pairs

🔁 Iteration Examples

🔹 Keys

for (Integer key : map.keySet()) {
    System.out.println("Key: " + key);
}

🔹 Values

for (String value : map.values()) {
    System.out.println("Value: " + value);
}

🔹 Entry (key-value pair)

for (Map.Entry<Integer, String> entry : map.entrySet()) {
    System.out.println(entry.getKey() + " => " + entry.getValue());
}

Using stream() : 
map.entrySet().stream()
    .forEach(entry -> System.out.println(entry.getKey() + " => " + entry.getValue()));

map.keySet().stream()
    .forEach(key -> System.out.println("Key: " + key));

map.values().stream()
    .forEach(value -> System.out.println("Value: " + value));

🚫 Not Thread-Safe

In multi-threaded environments, use:

Collections.synchronizedMap(new HashMap<>())
OR prefer ConcurrentHashMap for better concurrency

⚙️ Internal Working (Simplified)

1. Key is passed to hashCode()
2. Hash value is computed and converted to an array index
3. Value is stored at that index
4. If collision occurs → linked list / tree is used at that index
5. Resize happens if size > capacity * load factor

🆚 HashMap vs Other Maps

Feature	`HashMap`	`LinkedHashMap`	`TreeMap`	`Hashtable`
Ordering	❌	✅ Insertion	✅ Sorted keys	❌
Null Keys	✅ 1	✅ 1	❌ (throws NPE)	❌ (throws NPE)
Thread-safe	❌	❌	❌	✅ (but obsolete)
Performance	✅ Fast	✅ Slightly slower	⚠️ Slower	⚠️ Slower

✅ When to Use HashMap

Use HashMap when:

You need fast key-value lookups
You don’t need order
You’re working in a single-threaded environment
You’re okay with allowing null key/value

❗ Avoid When

You need sorted data → use TreeMap
You need insertion order → use LinkedHashMap
You need thread safety → use ConcurrentHashMap or Collections.synchronizedMap()

🔍 2)What is a Synchronized Map?

A SynchronizedMap is a wrapper around a regular map (like HashMap) that makes all its method calls thread-safe using synchronization (i.e., internal synchronized blocks).

🔒 It is useful when you want a thread-safe version of HashMap but don’t need the performance of ConcurrentHashMap.

📦 How to Create a SynchronizedMap

Use Collections.synchronizedMap():

import java.util.*;

public class Example {
    public static void main(String[] args) {
        Map<String, String> map = Collections.synchronizedMap(new HashMap<>());
        map.put("1", "One");
        map.put("2", "Two");
        System.out.println(map.get("1")); // One
    }
}

🧠 How It Works Internally

Collections.synchronizedMap() returns a wrapper object where every method is synchronized on the map’s monitor (synchronized (map)):

public V put(K key, V value) {
    synchronized (mutex) {
        return m.put(key, value);
    }
}

This ensures only one thread can access any method at a time — even for read operations.

⚠️ Iteration Must Be Manually Synchronized

Map<String, String> map = Collections.synchronizedMap(new HashMap<>());

synchronized (map) {
    for (String key : map.keySet()) {
        System.out.println(key + " => " + map.get(key));
    }
}

❗ Failing to synchronize during iteration may cause ConcurrentModificationException.

✅ When to Use `SynchronizedMap`

Use SynchronizedMap when:

You have low concurrency.
You want backward compatibility with old HashMap code.
You want nulls to be allowed, unlike ConcurrentHashMap.

------------------------------------------------------------------------------------------------

🔍 3)What is `ConcurrentHashMap`?

ConcurrentHashMap is a thread-safe, high-performance implementation of a hash map in Java, designed for concurrent access without the need for external synchronization.

📦 Package: java.util.concurrent.ConcurrentHashMap
✅ Introduced in Java 5

✅ Why Use It?

We need safe access by multiple threads to a shared map.
We want better performance than synchronizing an entire HashMap or using Hashtable.
And it provides atomic methods like putIfAbsent(), compute(), merge() so, we better to use
ConcurrentHashMap

🚫 Why not use `HashMap in multi-threading`?

HashMap is not thread-safe. Using it in multi-threaded code can lead to:

ConcurrentModificationException
Corrupted data
Infinite loops (e.g., during rehashing)

⚙️ How `ConcurrentHashMap` Works

Java Version	Internal Design
Java 7	Segment-based locking
Java 8+	Bucket-level fine-grained locks (no segments), uses CAS (Compare-And-Swap)

Instead of locking the entire map, only portions (buckets) of the map are locked during updates — greatly improving concurrency.

🧑‍💻 Example – Basic Usage

import java.util.concurrent.ConcurrentHashMap;

public class Example {
    public static void main(String[] args) {
        ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();
        map.put("1", "One");
        map.put("2", "Two");
        System.out.println(map.get("1")); // One
        map.putIfAbsent("2", "TwoAgain"); // Won't overwrite
        map.compute("2", (k, v) -> v + "-Updated");
        System.out.println(map); // {1=One, 2=Two-Updated}
    }
}

❌ Null Values Are Not Allowed

ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();
map.put(null, "value"); // ❌ NullPointerException
map.put("key", null);   // ❌ NullPointerException

Reason: null is ambiguous in concurrent environments (e.g., get returning null — is it absent or null?).

🔄 Atomic Methods

Method	Purpose
`putIfAbsent(key, val)`	Insert only if key is missing
`compute(key, remapFn)`	Update value atomically with a remapping function
`computeIfAbsent()`	Lazily compute if key is missing
`computeIfPresent()`	Update only if key is present
`merge()`	Merge existing and new values
`forEach()`	Safe concurrent iteration

🔧 Multithreaded Example

import java.util.concurrent.*;

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

        ExecutorService executor = Executors.newFixedThreadPool(5);

        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                map.merge("count", 1, Integer::sum);
            }
        };

        for (int i = 0; i < 5; i++) executor.submit(task);
        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.MINUTES);

        System.out.println("Final count: " + map.get("count")); // 5000
    }
}

🔐 ConcurrentHashMap vs SynchronizedMap vs Hashtable

Feature	`HashMap`	`Hashtable`	`SynchronizedMap`	`ConcurrentHashMap`
Thread-safe	❌ No	✅ Yes	✅ Yes (via wrapper)	✅ Yes (better concurrency)
Performance (multi-thread)	🚫 Bad	⚠️ Slow	⚠️ Slower	✅ Fast, scalable
Null keys/values	✅ Allowed	❌ Disallowed	✅ Allowed	❌ Not allowed
Read/Write Locking	❌ None	Full sync (method)	Full sync (method)	Fine-grained (bucket-level)
Use in modern apps	❌ No	❌ Obsolete	⚠️ Legacy-compatible	✅ Preferred

✅ Summary

Use ConcurrentHashMap when you need a thread-safe map with high concurrency.
Nulls are not allowed.
Provides atomic operations like putIfAbsent(), compute(), and merge().
Faster and more scalable than legacy alternatives like Hashtable.

✅ 1) HashMap vs ConcurrentHashMap

🔹 HashMap

A non-thread-safe map implementation in Java used to store key-value pairs.
Allows one null key and multiple null values.
Performance is high in a single-threaded environment, but it needs external synchronization in multi-threaded scenarios.

🔹 ConcurrentHashMap

A thread-safe alternative to HashMap that allows concurrent access by multiple threads.
Internally uses bucket-level locking (lock striping) to reduce contention and improve performance.
Null keys and null values are not allowed.

🔸 Comparison Table:

Feature	HashMap	ConcurrentHashMap
Thread-safe	❌ No	✅ Yes
Null Keys/Values	✅ One null key, many null values	❌ None allowed
Performance	Faster in single-threaded	Optimized for concurrency
Synchronization	Manually required	Built-in concurrency support
Use case	Non-threaded programs	Multi-threaded programs

✅ 2) SynchronizedMap vs ConcurrentHashMap

🔹 SynchronizedMap

Created using Collections.synchronizedMap().
Wraps a regular map with synchronized methods.
Whole map is locked for each operation.
Performance suffers under high concurrency.

🔹 ConcurrentHashMap

Designed for high-concurrency use cases.
Uses bucket-level locking for better performance.
Safe for simultaneous reads/writes without locking the whole map.

🔸 Comparison Table:

Feature	SynchronizedMap	ConcurrentHashMap
Thread Safety	✅ Yes	✅ Yes
Lock Granularity	Entire map	Segment-level (fine-grained)
Performance	Slower under load	Highly optimized
Null Keys/Values	Allows null	❌ Not allowed
Use During Iteration	Must externally sync	Safe for concurrent iteration

🔸 Example:

Map<String, String> syncMap = Collections.synchronizedMap(new HashMap<>());

Map<String, String> concMap = new ConcurrentHashMap<>();

Friday, 13 June 2025

HashMap vs SynchronizedMap vs ConcurrentHashMap in Java

🔍 1)What is a HashMap?

🧠 How Does It Work?

📌 Key Characteristics

✅ Example – Basic Usage

🔧 Common Methods

🔁 Iteration Examples

🔹 Keys

🔹 Values

🔹 Entry (key-value pair)

🚫 Not Thread-Safe

⚙️ Internal Working (Simplified)

🆚 HashMap vs Other Maps

❗ Avoid When

🔍 2)What is a Synchronized Map?

📦 How to Create a SynchronizedMap

🧠 How It Works Internally

⚠️ Iteration Must Be Manually Synchronized

✅ When to Use SynchronizedMap

🔍 3)What is ConcurrentHashMap?

✅ Why Use It?

ConcurrentHashMap

🚫 Why not use HashMap in multi-threading?

⚙️ How ConcurrentHashMap Works

🧑‍💻 Example – Basic Usage

❌ Null Values Are Not Allowed

🔄 Atomic Methods

🔧 Multithreaded Example

🔐 ConcurrentHashMap vs SynchronizedMap vs Hashtable

✅ Summary

✅ 1) HashMap vs ConcurrentHashMap

🔹 HashMap

🔹 ConcurrentHashMap

🔸 Comparison Table:

✅ 2) SynchronizedMap vs ConcurrentHashMap

🔹 SynchronizedMap

🔹 ConcurrentHashMap

🔸 Comparison Table:

No comments:

Post a Comment

🔍 1)What is a `HashMap`?

✅ When to Use `SynchronizedMap`

🔍 3)What is `ConcurrentHashMap`?

`ConcurrentHashMap`

🚫 Why not use `HashMap in multi-threading`?

⚙️ How `ConcurrentHashMap` Works