ConcurrentHashMap in Java

Declaration of ConcurrentHashMap in Java

public class ConcurrentHashMap<K,​V> extends AbstractMap<K,​V> implements ConcurrentMap<K,​V>, Serializable 

You can also try this code with Online Java Compiler

Run Code

K - key object type V - value object type

To create an instance:

ConcurrentHashMap<Key, Value> numbers = new ConcurrentHashMap<>()

You can also try this code with Online Java Compiler

Run Code

Features ConcurrentHashMap in Java

• ConcurrentHashMap is an enhanced version of the HashMap that deals with concurrent thread operations.
• Unlike the HashMap, it is synchronised and does not accept null as a key or value.
• The default concurrency level of a ConcurrenHashMap is 16. This means that a maximum of 16 threads can modify the map contents simultaneously. However, any number of threads can read the map at the same time.
• All objects, by default, can be divided into 16 segments based on the concurrency level. ConcurrentHashMaps implement a Segment/Bucket locking mechanism in which a thread locks a segment in the object it wants to operate on.
• It supports sequential and parallel bulk operations even to maps that are simultaneously modified by multiple threads.

Constructors of Java ConcurrentHashMap

Three important parameters are involved with the constructors of this class. 

• Concurrency level: It specifies the number of threads that would concurrently update the map.
• Load factor: It is a threshold factor used for control resizing.
• Initial capacity: It defines the number of entries the map can hold initially.

The ConcurrentHashMap has five constructors:

• ConcurrentHashMap() -
  
  • It creates a new, empty map with default concurrency level (16), load factor (0.75) and initial capacity (16).

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

You can also try this code with Online Java Compiler

Run Code

• ConcurrentHashMap(int initialCapacity) -
  
  •  It creates a new, empty map with default concurrency level (16), load factor (0.75) and the specified initial capacity.
  • IllegalArgumentException is thrown if the value of initial capacity is negative.

ConcurrentHashMap<String, Integer> evenNumbers = new ConcurrentHashMap<>(int initialCapacity);

You can also try this code with Online Java Compiler

Run Code

• ConcurrentHashMap(int initialCapacity, float loadFactor) -
  
  •  It creates a new, empty map with the default concurrency level (16) and the specified load factor, initial capacity.
  • IllegalArgumentException is thrown if the value of initial capacity or load-factor is negative.

ConcurrentHashMap<String, Integer> evenNumbers = new ConcurrentHashMap<>((int initialCapacity, float loadFactor);

You can also try this code with Online Java Compiler

Run Code

• ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) -
  
  •  It creates a new, empty map with the specified concurrency level, load factor and initial capacity.
  • IllegalArgumentException is thrown if the value of initial capacity, load factor, or concurrency level is negative.

ConcurrentHashMap<String, Integer> evenNumbers = new ConcurrentHashMap<>(int initialCapacity, float loadFactor, int concurrencyLevel);

You can also try this code with Online Java Compiler

Run Code

• ConcurrentHashMap(Map m) - 
  
  • It creates a new map with the same entries of the given map.

ConcurrentHashMap<String, Integer> evenNumbers = new ConcurrentHashMap<>(Map m);

You can also try this code with Online Java Compiler

Run Code

Try it on online java compiler.

Methods/Functions

Description of parameters:

• ParallelismThreshold is the estimated number of elements needed for an operation to be executed in parallel.
• Transformer is a function that returns the transformation of an element.
• Basis defines the initial default value for the reducer.
• Reducer is a commutative and associative combining function.

Basic operations of ConcurrentHashMap in Java

1. Adding elements

• put(), putAll() and putIfAbsent() methods are used to add elements into the map.
   

import java.util.concurrent.ConcurrentHashMap;
class AddElement 
{
    public static void main(String[] args) 
    {
        ConcurrentHashMap<String, Integer> evenNumbers = new ConcurrentHashMap<>();

        evenNumbers.put("Two", 2);
        evenNumbers.put("Four", 4);

        System.out.println("ConcurrentHashMap of even numbers: " + evenNumbers);

        ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>();
        numbers.put("One", 1);

        numbers.putAll(evenNumbers);

        numbers.putIfAbsent("Three", 3);
      
        System.out.println("ConcurrentHashMap of numbers: " + numbers);
    }
}

You can also try this code with Online Java Compiler

Run Code

Output:

ConcurrentHashMap of even numbers: {Four=4, Two=2}
ConcurrentHashMap of numbers: {One=1, Four=4, Two=2, Three=3}

2. Removing elements

• remove() is used to remove elements from the map.

import java.util.concurrent.ConcurrentHashMap;

public class RemoveElement 
{
  public static void main(String[] args) 
  {     
      ConcurrentHashMap<String, Integer> evenNumbers = new ConcurrentHashMap<>();

      evenNumbers.put("One", 1);
      evenNumbers.put("Two", 2);
      evenNumbers.put("Three", 3);
      evenNumbers.put("Four", 4);

      System.out.println("ConcurrentHashMap of numbers: " + evenNumbers);
      
      evenNumbers.remove("One");
      
      // Using remove() on a key-value pair 
      evenNumbers.remove("Three",3);
      
      // Using remove() on a key that has a different value
      evenNumbers.remove("four",2);
    
      System.out.println("ConcurrentHashMap of even numbers: " + evenNumbers);
   }
}

You can also try this code with Online Java Compiler

Run Code

Output:

ConcurrentHashMap of numbers: {One=1, Four=4, Two=2, Three=3}
ConcurrentHashMap of even numbers: {Four=4, Two=2}

3. Accessing elements

• entrySet(), values(), keys(), keySet() and elements() are used to access a set of elements all together.
• get(), getOrDefault() are used to obtain values of specified keys.

import java.util.concurrent.ConcurrentHashMap;

public class AccessElement 
{
  public static void main(String[] args) 
  {
      ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>();

      numbers.put("One", 1);
      numbers.put("Two", 2);
      numbers.put("Three", 3);
      numbers.put("Four", 4);
      
      System.out.println("ConcurrentHashMap Entries: " + numbers.entrySet());
      
      // Using keys() that returns an enumeration object
      Enumeration enum_keys= numbers.keys();
      System.out.print("ConcurrentHashMap Keys: ");
      
      while(enum_keys.hasMoreElements())
        System.out.print(enum_keys.nextElement() + " ");
      System.out.println();
      
      System.out.println("ConcurrentHashMap Values: " + numbers.values());
      
      System.out.println("Value of One is " + numbers.get("One"));
      
      // Using getOrDefault() where default value is set to -1
      System.out.println("Value of Five is " + numbers.getOrDefault("Five",-1));
   }
}

You can also try this code with Online Java Compiler

Run Code

Output:

ConcurrentHashMap Entries: [One=1, Four=4, Two=2, Three=3]
ConcurrentHashMap Keys: One Four Two Three 
ConcurrentHashMap Values: [1, 4, 2, 3]
Value of One is 1
Value of Five is -1

• Traversal - The iterator interface is used to traverse an Identity hash map. The next() method is used to print the consecutive elements of the map.

import java.util.concurrent.ConcurrentHashMap;

public class Traverse 
{
  public static void main(String[] args) 
  {
      ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>();

      numbers.put("One", 1);
      numbers.put("Two", 2);
      numbers.put("Three", 3);
      numbers.put("Four", 4);
      
      // Using entrySet()
      Iterator<ConcurrentHashMap.Entry<String, Integer> >
          itr = numbers.entrySet().iterator();
          
      // The hasNext() method checks if there is a next element
       while (itr.hasNext()) {
          ConcurrentHashMap.Entry<String, Integer> entry = itr.next();
          System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
      }
   }
}

You can also try this code with Online Java Compiler

Run Code

Output:

Key = One, Value = 1
Key = Four, Value = 4
Key = Two, Value = 2
Key = Three, Value = 3

Also see,  Swap Function in Java

Bulk Operations of ConcurrentHashMap in Java

• forEach() iterates over entries, keys or values and performs a specific action.

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

      numbers.put("One", 1);
      numbers.put("Two", 2);
      numbers.put("Three", 3);
      numbers.put("Four", 4);
      
      // forEach() without transformer 
      numbers.forEach(4, (k, v) -> System.out.println("key: " + k + ", value: " + v));

      // forEach() with transformer
      System.out.print("Values are ");
      numbers.forEach(4, (k, v) -> v, (v) -> System.out.print(v + ", "));
   }
}

You can also try this code with Online Java Compiler

Run Code

Output:

key: One, value: 1
key: Two, value: 2
key: Three, value: 3
key: Four, value: 4
Values are 1, 4, 2, 3,

• search() searches the map based on a function and returns the matched entry.

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

      numbers.put("One", 1);
      numbers.put("Two", 2);
      numbers.put("Three", 3);
      numbers.put("Four", 4);
      
      String key = numbers.search(3, (k, v) -> {return v == 2 ? k: null;});
      System.out.println("Searched value: " + key);
    }
}

You can also try this code with Online Java Compiler

Run Code

Output:

Searched value: Two

• reduce() is used to accumulate each entry, key or value in a map to perform a common task.

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

      numbers.put("One", 1);
      numbers.put("Two", 2);
      numbers.put("Three", 3);
      numbers.put("Four", 4);
      
      int sum = numbers.reduce(4, (k, v) -> v, (v1, v2) -> v1 + v2);
      System.out.println("Sum of all values: " + sum);
    }
}

You can also try this code with Online Java Compiler

Run Code

Output:

Sum of all values: 10

Frequently Asked Questions

What are iterators and enumerations?

An iterator is a cursor used to retrieve or remove elements one by one. They are universal and can be applied to any collection object. Iterator objects are created using the iterator() method present in the collection interface.

Enumerations are used to get elements from legacy collections like Vectors, HashTable. Like an iterator, it is a cursor used to read or retrieve elements. However, it cannot remove elements.

What are the differences between ConcurrentHashMap and HashTable?

• ConcurrentHashMap uses a multiple segment/bucket lock mechanism at the object level, while HashTable uses a single lock for the whole data.
• ConcurrentHashMap uses a fail-safe iterator, and HashTable uses an enumerator to iterate the values of their objects.
• ConcurrentHashMap is faster and has a better performance compared to the HashTable as it experiences synchronisation overhead.

Conclusion

The applications and programs built today are expected to have high efficiency and performance while executing concurrent tasks. Maps, hash tables and related interfaces involve multiple threads accessing and modifying their objects concurrently. In such situations, ConcurrentMaps and ConcurrentHashmaps play an essential role. This blog explains the features of ConcurrentHashMaps in detail. It also discusses the various methods provided by this class to perform basic and bulky operations.

Related Links:

• hash function in data structure
• Pros and Cons of Concurrency
• entryset java
• Internal Working of HashMap
• HashMap vs HashTable
• HashTables