ConcurrentMap Interface in Java

Last Updated : 14 Feb, 2025

The ConcurrentMap Interface is part of the Java Collections Framework and was introduced in JDK 1.5. It is designed for thread-safe concurrent access to its entries without compromising the consistency of the map. The interface resides in the java.util.concurrent package and extends the Map interface.

HashMap operations are not synchronized, while Hashtable provides synchronization. Though Hashtable is thread-safe, it is not very efficient. To solve this issue, the Java Collections Framework introduced ConcurrentMap in Java 1.5.

It extends the Map interface in Java.
ConcurrentNavigableMap<K,V> is the SubInterface.
ConcurrentMap is implemented by ConcurrentHashMap, and ConcurrentSkipListMap classes.
ConcurrentMap is known as a synchronized Map.

Example: This example demonstrates creating a ConcurrentMap using ConcurrentHashMap and adding key-value pairs to it.

Java

// Java Program to demonstrates 
// the working of ConcurrentMap
import java.util.concurrent.*;

public class Geeks {
    public static void main(String[] args) {
        
        // Create a ConcurrentMap instance 
        // using ConcurrentHashMap
        ConcurrentMap<Integer, String> map = new ConcurrentHashMap<>();

        // Adding key-value pairs using put()
        map.put(1, "Java");
        map.put(2, "Python");
        map.put(3, "C++");

        System.out.println("ConcurrentMap: " + map);
    }
}

Output

ConcurrentMap: {1=Java, 2=Python, 3=C++}

ConcurrentMap Hierarchy

Declaration of ConcurrentMap Interface

In Java, the declaration of ConcurrentMap Interface can be done as:

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

Note: Here, "k" is the type of the key, and "v" is the type of value.

Implementing Classes

To use ConcurrentMap we need to import it from the Java.util.concurrent package

import java.util.concurrent.ConcurrentMap;
or
import java.util.concurrent.*;

ConcurrentMap is implemented by two classes which are ConcurrentHashMap and ConcurrentSkipListMap.

ConcurrentHashMap is a high performance thread-safe map
ConcurrentSkipListMap is a thread-safe, sorted map with log(n) time complexity for operations.

Syntax:

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

Example: This example demonstrates using ConcurrentMap with ConcurrentHashMap to conditionally add, remove, and replace key-value pairs with thread-safe operations.

Java

// Java Program to illustrate methods
// of ConcurrentMap interface
import java.util.concurrent.*;

class Geeks {

    public static void main(String[] args)
    {
        // Since ConcurrentMap is an interface,
        // we create instance using ConcurrentHashMap
        ConcurrentMap<Integer, String> m 
        = new ConcurrentHashMap<Integer, String>();
        m.put(100, "Geeks");
        m.put(101, "For");
        m.put(102, "Geeks");

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

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

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

        // We can replace Hello with For
        m.replace(101, "Hello", "For");
        System.out.println("Map contents : " + m);
    }
}

Output

Map contents : {100=Geeks, 101=For, 102=Geeks}

Performing Various Operations on ConcurrentMap

1. Adding Elements: The put() method of ConcurrentSkipListMap is an in-built function in Java which associates the specified value with the specified key in this map. If the map previously contained a mapping for the key, the old value is replaced.

Example:

Java

// Java Program to demosntrates the working of put()
import java.util.concurrent.*;

class Geeks {
    public static void main(String[] args) {
        
        // Create a ConcurrentMap instance 
        // using ConcurrentHashMap
        ConcurrentMap<Integer, String> map = new ConcurrentHashMap<>();

        // Adding key-value pairs using put()
        map.put(1, "Java");
        map.put(2, "Python");
        map.put(3, "C++");

        System.out.println("ConcurrentMap contents: " + map);
    }
}

Output

ConcurrentMap contents: {1=Java, 2=Python, 3=C++}

2. Removing Elements: The remove() method of ConcurrentSkipListMap is an in-built function in Java which removes the mapping for the specified key from this map. The method returns null if there is no mapping for that particular key. After this method is performed the size of the map is reduced.

Example:

Java

// Java Program to demonstrates 
// the working of ConcurrentMap
import java.util.concurrent.*;

class Geeks {
    public static void main(String[] args)
    {
        // Create a ConcurrentMap instance using
        // ConcurrentHashMap
        ConcurrentMap<Integer, String> map
            = new ConcurrentHashMap<>();

        // Adding key-value pairs using put()
        map.put(1, "Java");
        map.put(2, "Python");
        map.put(3, "C++");

        System.out.println("ConcurrentMap: " + map);

        // Remove element with key 2
        map.remove(2);

        // Print the map contents after removal
        System.out.println(
            "ConcurrentMap contents after removal: " + map);
    }
}

Output

ConcurrentMap: {1=Java, 2=Python, 3=C++}
ConcurrentMap contents after removal: {1=Java, 3=C++}

3. Accessing Elements: We can access the elements of a ConcurrentSkipListMap using the get() method.

Example: This example demonstrates inserting key-value pairs into a ConcurrentMap and accessing values using the get() method.

Java

// Java Program to demonstrate accessing elements
import java.util.concurrent.*;

class Geeks {

    public static void main(String[] args)
    {

        // Instantiate an object
        // Since ConcurrentMap
        // is an interface so We use
        // ConcurrentSkipListMap
        ConcurrentMap<Integer, String> map 
        = new ConcurrentSkipListMap<Integer, String>();

        // insert mappings using put method
        map.put(100, "Geeks");
        map.put(101, "for");
        map.put(102, "Geeks");

        // Displaying the HashMap
        System.out.println("The Mappings are: ");
        System.out.println(map);

        // Display the value of 100
        System.out.println("The Value associated to "
                + "100 is : " + map.get(100));

        // Getting the value of 103
        System.out.println("The Value associated to "
                + "101 is : " + map.get(101));
    }
}

Output

The Mappings are: 
{100=Geeks, 101=for, 102=Geeks}
The Value associated to 100 is : Geeks
The Value associated to 101 is : for

4. Iterating Elements: We can use the iterator to traverse a ConcurrentMap by iterating over its Entry set accessing each key-value pair with next() method.

Example: This example demonstrates iterating over a ConcurrentSkipListMap using an Iterator to access and print each key-value pair.

Java

// Java Program to demonstrates 
// how to iterate over ConcurrentMap
import java.util.concurrent.*;
import java.util.*;

public class Geeks {

    public static void main(String[] args)
    {

        // Instantiate an object
        // Since ConcurrentMap
        // is an interface so We use
        // ConcurrentSkipListMap
        ConcurrentMap<Integer, String> map 
        = new ConcurrentSkipListMap<Integer, String>();

        // Add elements using put()
        map.put(8, "Third");
        map.put(6, "Second");
        map.put(3, "First");
        map.put(11, "Fourth");

        // Create an Iterator over the
        // ConcurrentSkipListMap
        Iterator<ConcurrentSkipListMap
                .Entry<Integer, String> > itr
                = map.entrySet().iterator();

        // The hasNext() method is used to check if there is
        // a next element The next() method is used to
        // retrieve the next element
        while (itr.hasNext()) {
            ConcurrentSkipListMap
                    .Entry<Integer, String> entry
                    = itr.next();
            System.out.println("Key = " + entry.getKey()
                    + ", Value = "
                    + entry.getValue());
        }
    }
}

Output

Key = 3, Value = First
Key = 6, Value = Second
Key = 8, Value = Third
Key = 11, Value = Fourth

Methods

Method	Description
compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)	Attempts to compute a mapping for the specified key and its current mapped value (or null if there is no current mapping).
computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)	If the specified key is not already associated with a value (or is mapped to null), attempts to compute its value using the given mapping function and enters it into this map unless null.
computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)	If the value for the specified key is present and non-null, attempts to compute a new mapping given the key and its current mapped value.
forEach(BiConsumer<? super K,? super V> action)	Performs the given action for each entry in this map until all entries have been processed or the action throws an exception.
getOrDefault(Object key, V defaultValue)	Returns the value to which the specified key is mapped, or defaultValue if this map contains no mapping for the key.
merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)	If the specified key is not already associated with a value or is associated with null, associates it with the given non-null value.
putIfAbsent(K key, V value)	If the specified key is not already associated with a value, associates it with the given value.
remove(Object key, Object value)	Removes the entry for a key only if currently mapped to a given value.
replace(K key, V value)	Replaces the entry for a key only if currently mapped to some value.
replace(K key, V oldValue, V newValue)	Replaces the entry for a key only if currently mapped to a given value.
replaceAll(BiFunction<? super K,? super V,? extends V> function)	Replaces each entry’s value with the result of invoking the given function on that entry until all entries have been processed or the function throws an exception.

Methods Inherited from Interface java.util.Map

Method	Description
clear()	Removes all of the mappings from this map (optional operation).
containsKey(Object key)	Returns true if this map contains a mapping for the specified key.
containsValue(Object value)	Returns true if this map maps one or more keys to the specified value.
entry(K k, V v)	Returns an immutable Map.Entry containing the given key and value.
entrySet()	Returns a Set view of the mappings contained in this map.
equals(Object o)	Compares the specified object with this map for equality.
get(Object key)	Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.
hashCode()	Returns the hash code value for this map.
isEmpty()	Returns true if this map contains no key-value mappings.
keySet()	Returns a Set view of the keys contained in this map.
of()	Returns an immutable map containing zero mappings.
of(K k1, V v1)	Returns an immutable map containing a single mapping.
of(K k1, V v1, K k2, V v2)	Returns an immutable map containing two mappings.
of(K k1, V v1, K k2, V v2, K k3, V v3)	Returns an immutable map containing three mappings.
of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4)	Returns an immutable map containing four mappings.
of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5)	Returns an immutable map containing five mappings.
of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6)	Returns an immutable map containing six mappings.
of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7)	Returns an immutable map containing seven mappings.
of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8)	Returns an immutable map containing eight mappings.
of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9)	Returns an immutable map containing nine mappings.
of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10)	Returns an immutable map containing ten mappings.
ofEntries(Map.Entry<? extends K,? extends V>… entries)	Returns an immutable map containing keys and values extracted from the given entries.
put(K key, V value)	Associates the specified value with the specified key in this map (optional operation).
putAll(Map<? extends K,? extends V> m)	Copies all of the mappings from the specified map to this map (optional operation).
remove(Object key)	Removes the mapping for a key from this map if it is present (optional operation).
size()	Returns the number of key-value mappings in this map.
values()	Returns a Collection view of the values contained in this map.

ConcurrentHashMap in Java

bishaldubey

Improve

Article Tags :

Practice Tags :

ConcurrentMap Interface in Java

ConcurrentMap Hierarchy

Declaration of ConcurrentMap Interface

Implementing Classes

Performing Various Operations on ConcurrentMap

Methods

Methods Inherited from Interface java.util.Map

Similar Reads

Thank You!

What kind of Experience do you want to share?