Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/java/concurrenthashmap-in-java/ below:

ConcurrentHashMap in Java - GeeksforGeeks

Last Updated : 14 Feb, 2025

In Java, the ConcurrentHashMap is a thread-safe implementation of the Map interface. It allows multiple threads to read and write data simultaneously, without the need for locking the entire map. Unlike a regular HashMap, which is not thread-safe, ConcurrentHashMap ensures that the operations are thread-safe, making it ideal for scenarios where multiple threads need to access and modify the map concurrently.

• Provides thread-safe operations without locking the entire map.
• Allows multiple threads to operate concurrently by dividing the map into segments.
• Supports atomic operations like putIfAbsent(), replace() and remove()
• The default concurrency level of ConcurrentHashMap is 16
• Inserting null objects is not possible in ConcurrentHashMap as a key or value.

Example: This example demonstrates basic operations like adding, retrieving, and removing elements on a ConcurrentHashMap in a multi-threaded environment.

// Java Program to demosntrates the 
// working of ConcurrentHashMap
import java.util.concurrent.ConcurrentHashMap;
public class Geeks {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

        // Adding elements to the map
        map.put("A", 1);
        map.put("B", 2);
        map.put("C", 3);

        System.out.println("Map size: " + map.size());

        // Getting values from the map
        System.out.println("Value of A: " + map.get("A"));

        // Removing elements from the map
        map.remove("B");
        System.out.println("After removal map size is: " + map.size());
    }
}

Map size: 3
Value of A: 1
After removal map size is: 2

It implements Serializable, ConcurrentMap<K,​ V>, Map<K,​ V> interfaces and extends  AbstractMap<K, ​V> class.

In Java, the declaration of ConcurrentHashMap can be done as:

ConcurrentHashMap<KeyType, ValueType> map = new ConcurrentHashMap<>();

Note: Here the KeyType is the type of the key in the map and ValueType is the type of values associated with the keys.

• Concurrency-Level: It is the number of threads concurrently updating the map. The implementation performs internal sizing to try to accommodate this many threads.
• Load-Factor: It’s a threshold, used to control resizing.
• Initial Capacity: Accommodation of a certain number of elements initially provided by the implementation. if the capacity of this map is 10. It means that it can store 10 entries.

Constructor

Description

ConcurrentHashMap()

This constructor creates a new, empty map with a default initial capacity (16), load factor (0.75) and concurrencyLevel (16).

ConcurrentHashMap(int initialCapacity)

This constructor creates a new, empty map with the specified initial capacity, and with default load factor (0.75) and concurrencyLevel (16).

ConcurrentHashMap(int initialCapacity, float loadFactor)

This constructor creates a new, empty map with the specified initial capacity and load factor and with the default concurrencyLevel (16)

ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel)

This constructor creates a new, empty map with the specified initial capacity, load factor, and concurrency level.

ConcurrentHashMap(Map m)

This constructor creates a new map with the same mappings as the given map.

Example: This example demonstrates the usage of various ConcurrentHashMap methods.

// Java program to demonstrate working of various methods
// like put(), putIfAbsent(), remove() and replace()
import java.util.concurrent.*;
class Geeks {

    public static void main(String[] args)
    {
        // create an instance of
        // ConcurrentHashMap
        ConcurrentHashMap<Integer, String> m
            = new ConcurrentHashMap<>();

        // Insert mappings using
        // put method
        m.put(100, "Hello");
        m.put(101, "Geeks");
        m.put(102, "Geeks");

        // 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, "Geeks");

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

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

{100=Hello, 102=Geeks, 103=Hello}

1. Adding Elements: We can use put() or putAll() to insert element to a ConcurrentHashMap.

Example: This example demonstrates creating a ConcurrentHashMap, adding elements to it, and then copying its contents to another ConcurrentHashMap.

// Java Program to demonstrates 
// the working of put()
import java.util.concurrent.*;
public class Geeks{

    public static void main(String[] args) {
        // Create ConcurrentHashMap
        ConcurrentHashMap<String, String> map1 = new ConcurrentHashMap<>();

        // Add elements to map
        map1.put("1", "One");
        map1.put("2", "Two");
        map1.put("3", "Three");
        map1.put("4", "Four");
        map1.put("5", "Five");
        map1.put("6", "Six");

        // Print map1
        System.out.println("map1: " + map1);

        // Create a new map and copy all entries from map1
        ConcurrentHashMap<String, String> map2 = new ConcurrentHashMap<>(map1);

        // Print map2
        System.out.println("map2: " + map2);
    }
}

map1: {1=One, 2=Two, 3=Three, 4=Four, 5=Five, 6=Six}
map2: {1=One, 2=Two, 3=Three, 4=Four, 5=Five, 6=Six}

2. Removing Elements: We can use the remove() method to remove elements from the ConcurrentHashMap. To clear the entire map, we can use the clear().

Example: This example demonstrates adding elements to a ConcurrentHashMap removing entries by key, and clearing the map.

// Java program to demonstrate removing
// elements from ConcurrentHashMap
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

public class Geeks{

    public static void main(String[] args)
    {
        // Creating ConcurrentHashMap
        Map<String, String> m
                = new ConcurrentHashMap<String, String>();

        // Adding elements to the map
        // using put() method
        m.put("1", "One");
        m.put("2", "Two");
        m.put("3", "Three");
        m.put("4", "Four");
        m.put("5", "Five");
        m.put("6", "Six");

        System.out.println("Map: " + m);
        System.out.println();

        // Removing the mapping
        // with existing key 6
        // using remove() method
        String s = m.remove("6");

        // Printing the map after remove()
        System.out.println(
                "After removing mapping with key 6:");
        System.out.println("Map: " + m);
        System.out.println("Value removed: "
                + s);
        System.out.println();

        // Removing the mapping
        // with non-existing key 10
        // using remove() method
        s = m.remove("10");

        // Printing the map after remove()
        System.out.println(
                "After removing mapping with key 10:");
        System.out.println("Map: " + m);
        System.out.println("Value removed: "
                + s);
        System.out.println();

        // Now clear the map using clear()
        m.clear();

        System.out.println("Map after use of clear(): "
                + m);
    }
}

Output:

3. Accessing Elements: We can use the  get() method to access the elements of the ConcurrentHashMap.

Example: This example demonstrates inserting elements into a ConcurrentHashMap and retrieving values using the get() method based on specific keys.

// Java Program Demonstrate accessing
// elements of ConcurrentHashMap
import java.util.concurrent.*;
class Geeks {
    public static void main(String[] args)
    {

        // create an instance of ConcurrentHashMap
        ConcurrentHashMap<Integer, String> m
                = new ConcurrentHashMap<Integer, String>();

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

        // Displaying the HashMap

        System.out.println("ConcurrentHashMap:" + m);

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

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

ConcurrentHashMap:{100=Geeks, 101=for, 102=Geeks, 103=Contribute}
The Value associated to 100 is : Geeks
The Value associated to 103 is : Contribute

4. Iterating Elements: We can use the Iterator interface to traverse over the elements of ConcurrentHashMap.

Example: This example demonstrates iterating over a ConcurrentHashMap using an iterator to access both keys and values.

// Java Program for traversing a
// ConcurrentHashMap
import java.util.*;
import java.util.concurrent.*;
public class Geeks {
    public static void main(String[] args)
    {
        // create an instance of ConcurrentHashMap
        ConcurrentHashMap<Integer, String> m
                = new ConcurrentHashMap<Integer, String>();

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

        // Create an Iterator over the
        // ConcurrentHashMap
        Iterator<ConcurrentHashMap.Entry<Integer, String> >
                i = m.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 (i.hasNext()) {
            ConcurrentHashMap.Entry<Integer, String> entry
                    = i.next();
            System.out.println("Key = " + entry.getKey()
                    + ", Value = "
                    + entry.getValue());
        }
    }
}

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

Methods

Description

Method

Description

Method

Description

HashTable:

• Hashtable is an implementation of Map data structure
• This is a legacy class in which all methods are synchronized on Hashtable instances using the synchronized keyword.
• Thread-safe as it’s method are synchronized

ConcurrentHashMap:

• ConcurrentHashMap implements Map data structure and also provide thread safety like Hashtable.
• It works by dividing complete hashtable array into segments or portions and allowing parallel access to those segments.
• The locking is at a much finer granularity at a hashmap bucket level.
• Use ConcurrentHashMap when you need very high concurrency in your application.
• It is a thread-safe without synchronizing the whole map.
• Reads can happen very fast while the write is done with a lock on segment level or bucket level.
• There is no locking at the object level.
• ConcurrentHashMap doesn’t throw a ConcurrentModificationException if one thread tries to modify it while another is iterating over it.
• ConcurrentHashMap does not allow NULL values, so the key can not be null in ConcurrentHashMap
• ConcurrentHashMap doesn’t throw a ConcurrentModificationException if one thread tries to modify it, while another is iterating over it.

Map ht = new Hashtable();

Map chm = new ConcurrentHashMap();

No

No

No

No (does not allow either null keys or values)

Yes

Slow due to synchronization overhead.

Note: If a thread-safe highly-concurrent implementation is desired, then it is recommended to use ConcurrentHashMap in place of Hashtable.

• Thread-safe: ConcurrentHashMap is designed to be used by multiple threads simultaneously, making it an ideal choice for applications that need to handle concurrent access to data.
• Fine-grained locking: Unlike other synchronization mechanisms that lock the entire data structure, ConcurrentHashMap uses fine-grained locking to lock only the portion of the map being modified. This makes it highly scalable and efficient for concurrent operations.
• Atomic operations: ConcurrentHashMap provides several methods for performing atomic operations, such as putIfAbsent(), replace(), and remove(), which can be useful for implementing complex concurrent algorithms.
• High performance: Due to its fine-grained locking mechanism, ConcurrentHashMap is able to achieve high performance, even under heavy concurrent access.

• Higher memory overhead: The fine-grained locking mechanism used by ConcurrentHashMap requires additional memory overhead compared to other synchronization mechanisms.
• Complexity: The fine-grained locking mechanism used by ConcurrentHashMap can make the code more complex, especially for developers who are not familiar with concurrent programming.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4