Java ConcurrentHashMap

In this tutorial, we will learn about the Java ConcurrentHashMap class and its operations with the help of examples.

The ConcurrentHashMap class of the Java collections framework provides a thread-safe map. That is, multiple threads can access the map at once without affecting the consistency of entries in a map.

ConcurrentHashMap class is introduced in JDK 1.5, which implements ConcurrentMap as well as Serializable interface also. ConcureentHashMap is enhancement of HashMap as we know that while dealing with Threads in our application HashMap is not a good choice because performance wise HashMap is not upto the mark.

Example:

// Java program to demonstrate working of ConcurrentHashMap 
import java.util.concurrent.*; 
class ConcurrentHashMapDemo { 
	public static void main(String[] args) 
	{ 
		ConcurrentHashMap m = new ConcurrentHashMap(); 
		m.put(100, "Hello"); 
		m.put(101, "Codemistic"); 
		m.put(102, "coder"); 

		// Here we cant add Hello because 101 key 
		// is already present in ConcurrentHashMap object 
		m.putIfAbsent(101, "Hello"); 

		// We can remove entry because 101 key 
		// is associated with For value 
		m.remove(101, "Codemistic"); 

		// Now we can add Hello 
		m.putIfAbsent(103, "Hello"); 

		// We cant replace Hello with For 
		m.replace(101, "Hello", "For"); 
		System.out.println(m); 
	} 
} 

output:
{100=Hello, 102=coder, 103=Hello}

Key points of ConcurrentHashMap

• The underlined data structure for ConcurrentHashMap is Hashtable.
• ConcurrentHashMap class is thread-safe i.e. multiple thread can operate on a single object without any complications.
• At a time any number of threads are applicable for read operation without locking the ConcurrentHashMap object which is not there in HashMap.
• In ConcurrentHashMap, the Object is divided into number of segments according to the concurrency level.
• Default concurrency-level of ConcurrentHashMap is 16.
• In ConcurrentHashMap, at a time any number of threads can perform retrieval operation but for updation in object, thread must lock the particular segment in which thread want to operate.This type of locking mechanism is known as Segment locking or bucket locking.Hence at a time 16 updation operations can be performed by threads.
• null insertion is not possible in ConcurrentHashMap as key or value.

Methods in Java LinkedHashMap