ConcurrentHashMap in Java – A Deep Dive

ConcurrentHashMap is an extensively used class in Java for managing data in multi-threaded environments. It lets in a couple of threads to access the map simultaneously without locking the entire information structure, making it ideal for conditions wherein high-performance access is needed.

Unlike traditional maps, it manages synchronisation in a way that minimises the performance impact, allowing better scaling when multiple threads are working with shared data. This makes it a popular preference for applications where speed and data consistency are essential.

In this blog, we can discover what ConcurrentHashMap is and what are their key features, along with differences from other map implementations.

Also Read: HashMap in Java

What is ConcurrentHashMap in Java?

ConcurrentHashMap is a part of Java’s java.Util.Concurrent package, designed for dealing with maps in multi-threaded environments. It lets in multiple threads to read and write without inflicting data inconsistency. Thanks to its efficient inner locking mechanism which will only lock the part of the map when needed. This ensures overall high performance in comparison to using simple hashmaps.

It divides the map into segments, so only specific segments get locked during updates. This approach allows more threads to work in parallel, making it suitable for scenarios where high concurrency is required. The design helps reduce the contention that can slow down applications.

The class also offers thread-safe operations like putIfAbsent() and computeIfPresent(), which help in performing atomic updates on the map. These features make it a preferred choice when dealing with shared data in concurrent programs.

Also Read: Java Tutorial for Beginners

The syntax of creating a ConcurrentHashMap in Java follows the general format of other collections but with some specific details. Here’s the basic syntax:

ConcurrentHashMap<K, V> map = new ConcurrentHashMap<>();

In this syntax:

• K is the type of key that the map will store.
• V is the type of value associated with those keys.

The above line creates an empty ConcurrentHashMap where K and V need to be replaced with the desired data types. For example, if you want a map with String as keys and Integer as values, the syntax would be:

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

Example of ConcurrentHashMap

Here’s a basic example of the usage of ConcurrentHashMap in Java. This example demonstrates adding, retrieving, and updating elements inside the map.

Output

Explanation:

1. Creating the Map: We create a ConcurrentHashMap named map with String as the key type and Integer as the value type.
2. Adding Elements: We add key-value pairs using the put() method. For example, “Apple” is associated with the value 3.
3. Retrieving Values: The get() method fetches the value associated with a specified key.
4. Updating Values: We update the value for an existing key using put(), which will overwrite the previous value.
5. Conditional Insert: The putIfAbsent() method provides a key-fee pair only if the key isn’t always already there.
6. Removing Entries: The remove() method deletes the specified key-value pair from the map.
7. Checking Existence: The containsKey() approach tests if a selected specific key is present within the map.

Key Points of ConcurrentHashMap

Here are some key points about ConcurrentHashMap in Java:

• Thread-Safe Operations: It allows a couple of threads to get access to and alter the map simultaneously without inflicting record inconsistencies.
• Segmented Locking: The map is split into segments, and the only section which is being accessed is now locked.
• No Null Keys or Values: Unlike HashMap, it does not allow null keys or values. Trying to add a null will result in a NullPointerException.
• Atomic Operations: Provides thread-safe methods such as putIfAbsent(), remove(), and replace() for atomic updates.
• Iterators Are Weakly Consistent: The iterators do not throw ConcurrentModificationException and reflect some, but not necessarily all, of the changes made during iteration.
• Better Performance Compared to Synchronized Maps: It offers higher scalability because only specific segments are locked instead of the entire map.
• Supports Concurrent Reads and Writes: Multiple threads can read from the map and update different segments at the same time, enhancing concurrency.
• Customizable Concurrency Level: Allows setting the estimated number of concurrent threads accessing the map, enabling performance tuning.
• Memory Overhead: Slightly higher memory usage due to segmented locking and internal structures.
• Suitable for High-Concurrency Scenarios: Ideal for applications that require frequent read/write operations with many threads.

Also Read: Learn How to Iterate HashMap in Java

Constructors of ConcurrentHashMap

Here are the four types of constructors for ConcurrentHashMap in Java, along with code syntax and explanations:

1. ConcurrentHashMap(int initialCapacity)

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

Explanation:

• This constructor initialises a ConcurrentHashMap with a special preliminary capacity.
• InitialCapacity defines the range of buckets that the map will begin with an initially hold mode.
• If the approximate size of the map is known beforehand, you can set the initial capacity and can also help reduce the overall need for resizing, which will automatically improve performance.

2. ConcurrentHashMap(int initialCapacity, float loadFactor)

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

Explanation:

• This constructor allows you to specify both the initial capacity and the load factor.
• initialCapacity is the starting size of the map, while loadFactor determines when the map should increase its capacity.
• A loadFactor of 0.75 means that the map will resize when 75% of the current capacity is filled.
• Setting the load factor can help optimise memory usage and control how often the map resizes.

3. ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel)

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

Explanation:

• This constructor allows for setting the initialCapacity, loadFactor, and concurrencyLevel.
• concurrencyLevel is the estimated number of threads that will access the map simultaneously.
• The map is internally divided into segments, and the concurrencyLevel determines the number of segments.
• A higher concurrencyLevel increases the number of segments, which can reduce contention when many threads are accessing the map.

4. ConcurrentHashMap(Map m)

Explanation:

• This constructor lets you specify both the preliminary potential and the same key value mappings.
• InitialCapacity is set to hold enough space, along with all the mapping length of the map m, at the same time as loadFactor determines when the map should grow its ability.
• There is a loadFactor of 0.75, which means that it will resize when you fill the current capacity to 75%
• Setting the load factor can help optimise memory usage and control how often the map resizes.

Basic Operations on ConcurrentHashMap

ConcurrentHashMap in Java supports various basic operations for adding, updating, retrieving, and removing elements. Below are some commonly used operations along with explanations, examples, and executable code.

1. Inserting an Element (put())

The put() method adds a key-value pair to the map or updates the value if the key already exists.

Example

Output

2. Retrieving an Element (get())

The get() method retrieves the value associated with a given key.

It returns the cost mapped to the specified key. If the key is not located, it can return null or a default cost the usage of getOrDefault().

Example:

Output

3. Removing an Element (remove())

The remove() method deletes a key-value pair from the map. The method removes the entry associated with the given key. If the key is not found, nothing happens.

Example:

Output:

4. Conditional Insertion (putIfAbsent())

The putIfAbsent() method adds a key-price pair only when the key is not available. This approach tests if the key remains absent inside the map earlier than inserting the value. If the key’s already present, it does not do anything.

Example:

Output:

5. Replacing an Element (replace())

The replace() method updates the price for a specific key if the key is present. You can update the value that is associated with a given key if it exists. There is likewise a version that replaces the value if it matches a designated old price.

Example:

Output:

6. Checking if a Key Exists (containsKey())

The containsKey() method checks if a specific key is there or not in the map. It returns true if the map carries the given key, otherwise false.

Example:

Output:

7. Iterating Over the Map

The ConcurrentHashMap allows iterating over its elements using more suitable loops or iterators. You can use a for-each loop to iterate over the key-price pairs. The iterator is weakly constant, which means it displays the map’s state whilst the new release starts and may reflect some updates made to the map.

Example:

Output:

These basic operations help you manage data effectively using ConcurrentHashMap, ensuring thread safety in concurrent programs.

Complexity of ConcurrentHashMap in Java

ConcurrentHashMap vs Hashtable

Method Reference of ConcurrentHashMap

Advantages of ConcurrentHashMap

• High Concurrency: Allows multiple threads to read and write simultaneously without blocking each other.
• Segmented Locking: Reduces contention by locking only specific segments, not the entire map.
• Thread Safety: Provides built-in thread-safe operations without external synchronisation.
• Atomic Methods: Supports atomic operations like putIfAbsent(), remove(), and replace().
• Weakly Consistent Iterators: Iterators can be used safely in multi-threaded environments without throwing exceptions.
• Scalable Performance: Better performance compared to Hashtable in high-concurrency scenarios.

Disadvantages of ConcurrentHashMap

• No Null Keys/Values: Does not support null as a key or value, which may limit use cases.
• Weak Iterator Consistency: Iterators may not reflect the latest changes, which can lead to inconsistent views.
• Memory Overhead: Requires more memory due to the internal segment structure.
• Complex Locking Mechanism: The segmented locking can be harder to understand compared to simple synchronisation.
• Limited Atomicity Guarantees: Only specific methods provide atomic operations, requiring careful use in some scenarios.

Also Read:  Java Interview Questions and Answers

Conclusion

ConcurrentHashMap is a powerful tool for handling data in multi-threaded Java applications. Its segmented locking mechanism ensures that multiple threads can access and update the map concurrently, leading to higher performance in high-concurrency scenarios. This makes it a popular choice for applications that require frequent read-and-write operations.

While it offers many advantages, such as atomic methods and weakly consistent iterators, there are some limitations, like the inability to store null keys or values. Overall, ConcurrentHashMap strikes a good balance between thread safety and performance, making it a suitable choice for developers working with concurrent programming in Java. If you want to master Java, consider pursuing Hero Vired’s Certificate Program in Application Development.