Synchronized HashMap in Java

A Synchronized HashMap is simply a thread-safe version of HashMap, created using the Collections.synchronizedMap() wrapper method.

It ensures only one thread can access the map at a time, providing full synchronization (global lock).

What is a Synchronized HashMap?

A Synchronized HashMap is a thread-safe version of HashMap.

If multiple threads modify it simultaneously, it may cause:

Data inconsistency
Race conditions
ConcurrentModificationException
Even structure corruption (in older JVMs)

To make a HashMap thread-safe, Java provides:

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

This wraps the HashMap inside a synchronized wrapper.

All operations (put(), get(), remove()) become synchronized internally.

Package

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

How Synchronized HashMap Works Internally

It uses a single lock for the entire map.

Simplified internal code:

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

Effects:

Thread-safe
Slower when multiple threads operate
Only one thread can access any map operation at a time

Creating a Synchronized HashMap

1. Using Collections.synchronizedMap()

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

2. Simple Example

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

map.put("A", 1);
map.put("B", 2);

System.out.println(map.get("A"));

Iterating a Synchronized HashMap (IMPORTANT)

Even though the map is synchronized, iteration IS NOT thread-safe.

You must use a synchronized block:

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

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

Skipping the synchronized block may cause ConcurrentModificationException.

Complete Example

import java.util.*;

public class Main {
    public static void main(String[] args) {

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

        map.put("A", 1);
        map.put("B", 2);

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

Drawbacks of SynchronizedHashMap

Issue	Explanation
Slow	Entire map is locked for every operation
No scalability	Not good for high concurrency
Weak concurrency	Iteration needs manual synchronization

Alternatives to Synchronized HashMap

Option	Thread-safe	Performance	Notes
Collections.synchronizedMap	Yes	Slow	Uses single lock
Hashtable	Yes	Slow	Legacy, synchronized methods
ConcurrentHashMap	Yes	Fast	Fine-grained locking, best choice

Difference: SynchronizedMap vs ConcurrentHashMap

Feature	SynchronizedMap	ConcurrentHashMap
Thread Safety	Thread-safe using global lock	Thread-safe using fine-grained locking (Java 8+ uses CAS + bins)
Locking Mechanism	Locks the entire map for every operation	Locks only portions (buckets/segments), allowing concurrent reads/writes
Performance	Slow under heavy concurrency	High-performance, scalable under multiple threads
Null Keys / Values	Not allowed	Not allowed
Iteration	Fail-fast (throws `ConcurrentModificationException`)	Weakly consistent (does not throw exceptions, may reflect some updates)
Read Operations	Require lock → slower	Mostly lock-free → faster
Write Operations	Single thread at a time	Multiple threads can update concurrently
Use Case	Simple thread safety for small maps	High-performance concurrent applications

Difference: SynchronizedMap vs Hashtable vs ConcurrentHashMap

Feature	Hashtable	SynchronizedMap	ConcurrentHashMap
Thread Safety	Yes (fully synchronized)	Yes (wrapper makes it synchronized)	Yes (high-performance concurrency)
Synchronization Type	Method-level locking	Object-level locking (on entire map)	Fine-grained locking (bucket-level)
Performance	Slowest (full map lock)	Slow (full map lock)	Fastest (no global lock)
Allows Null Key/Value	No null key/value	No null key/value	No null key/value
Concurrency Level	Very low	Very low	Very high (multiple threads can update safely)
Iteration Behavior	Fail-Fast	Fail-Fast	Weakly Consistent (no exceptions)
Introduced In	Java 1.0	Java 1.2	Java 1.5
Use Case	Legacy code	Wrap a normal map for basic thread safety	High-performance concurrent applications
Underlying Structure	HashTable	Any Map (usually HashMap)	Hash buckets (Java 8 uses CAS + tree bins)
Null Handling Reason	Checking null causes ambiguity in sync methods	Follows Hashtable rules	Avoid ambiguity in concurrent operations

When to Use Synchronized HashMap?

Use it when:

Few threads
Small data volume
Performance is not critical
You need simple, full synchronization

Avoid it when:

Many threads
High read/write operations
You need scalability

In such cases, always use ConcurrentHashMap.

Real-Life Use Cases

Small shared configuration maps
Simple utilities in multi-threaded environments
Legacy code needing thread-safety

Points to Remember

HashMap is not thread-safe
SynchronizedMap adds global locking
Must use manual synchronization during iteration
Slower for multi-threaded applications
ConcurrentHashMap is the recommended modern alternative

Core Java tutorial for beginners