Dans ce didacticiel, nous allons découvrir la classe Java ConcurrentHashMap et ses opérations à l'aide d'exemples.
La ConcurrentHashMap
classe du framework de collections Java fournit une carte thread-safe. Autrement dit, plusieurs threads peuvent accéder à la carte à la fois sans affecter la cohérence des entrées dans une carte.
Il implémente l'interface ConcurrentMap.
Créer un ConcurrentHashMap
Afin de créer un hashmap simultané, nous devons d'abord importer le java.util.concurrent.ConcurrentHashMap
package. Une fois le package importé, voici comment créer des hashmaps simultanés en Java.
// ConcurrentHashMap with capacity 8 and load factor 0.6 ConcurrentHashMap numbers = new ConcurrentHashMap(8, 0.6f);
Dans le code ci-dessus, nous avons créé une table de hachage simultanée nommée nombres.
Ici,
- Clé - un identifiant unique utilisé pour associer chaque élément (valeur) dans une carte
- Valeur - éléments associés par des clés dans une carte
Remarquez la pièce new ConcurrentHashMap(8, 0.6)
. Ici, le premier paramètre est la capacité et le deuxième paramètre est loadFactor .
- capacité - La capacité de cette carte est 8. Cela signifie qu'elle peut stocker 8 entrées.
- loadFactor - Le facteur de charge de cette carte est de 0,6. Cela signifie que chaque fois que notre table de hachage est remplie à 60%, les entrées sont déplacées vers une nouvelle table de hachage de deux fois la taille de la table de hachage d'origine.
Capacité par défaut et facteur de charge
Il est possible de créer une carte de hachage simultanée sans définir sa capacité et son facteur de charge. Par exemple,
// ConcurrentHashMap with default capacity and load factor ConcurrentHashMap numbers1 = new ConcurrentHashMap();
Par défaut,
- la capacité de la carte sera de 16
- le facteur de charge sera de 0,75
Création de ConcurrentHashMap à partir d'autres cartes
Voici comment créer une carte de hachage simultanée contenant tous les éléments d'autres cartes.
import java.util.concurrent.ConcurrentHashMap; import java.util.HashMap; class Main ( public static void main(String() args) ( // Creating a hashmap of even numbers HashMap evenNumbers = new HashMap(); evenNumbers.put("Two", 2); evenNumbers.put("Four", 4); System.out.println("HashMap: " + evenNumbers); // Creating a concurrent hashmap from other map ConcurrentHashMap numbers = new ConcurrentHashMap(evenNumbers); numbers.put("Three", 3); System.out.println("ConcurrentHashMap: " + numbers); ) )
Production
HashMap: (Quatre = 4, Deux = 2) ConcurrentHashMap: (Quatre = 4, Deux = 2, Trois = 3)
Méthodes de ConcurrentHashMap
La ConcurrentHashMap
classe fournit des méthodes qui nous permettent d'effectuer diverses opérations sur la carte.
Insérer des éléments dans ConcurrentHashMap
put()
- insère le mappage clé / valeur spécifié dans la carteputAll()
- insère toutes les entrées de la carte spécifiée dans cette carteputIfAbsent()
- insère le mappage clé / valeur spécifié dans la carte si la clé spécifiée n'est pas présente dans la carte
Par exemple,
import java.util.concurrent.ConcurrentHashMap; class Main ( public static void main(String() args) ( // Creating ConcurrentHashMap of even numbers ConcurrentHashMap evenNumbers = new ConcurrentHashMap(); // Using put() evenNumbers.put("Two", 2); evenNumbers.put("Four", 4); // Using putIfAbsent() evenNumbers.putIfAbsent("Six", 6); System.out.println("ConcurrentHashMap of even numbers: " + evenNumbers); //Creating ConcurrentHashMap of numbers ConcurrentHashMap numbers = new ConcurrentHashMap(); numbers.put("One", 1); // Using putAll() numbers.putAll(evenNumbers); System.out.println("ConcurrentHashMap of numbers: " + numbers); ) )
Production
ConcurrentHashMap de nombres pairs: (Six = 6, Four = 4, Two = 2) ConcurrentHashMap de nombres: (Six = 6, One = 1, Four = -4, Two = 2)
Accéder aux éléments ConcurrentHashMap
1. Utilisation de entrySet (), keySet () et values ()
entrySet()
- renvoie un ensemble de tous les mappages clé / valeur de la cartekeySet()
- retourne un ensemble de toutes les clés de la cartevalues()
- renvoie un ensemble de toutes les valeurs de la carte
Par exemple,
import java.util.concurrent.ConcurrentHashMap; class Main ( public static void main(String() args) ( ConcurrentHashMap numbers = new ConcurrentHashMap(); numbers.put("One", 1); numbers.put("Two", 2); numbers.put("Three", 3); System.out.println("ConcurrentHashMap: " + numbers); // Using entrySet() System.out.println("Key/Value mappings: " + numbers.entrySet()); // Using keySet() System.out.println("Keys: " + numbers.keySet()); // Using values() System.out.println("Values: " + numbers.values()); ) )
Production
ConcurrentHashMap: (Un = 1, Deux = 2, Trois = 3) Mappages clé / valeur: (Un = 1, Deux = 2, Trois = 3) Clés: (Un, Deux, Trois) Valeurs: (1, 2, 3 )
2. Utilisation de get () et getOrDefault ()
get()
- Renvoie la valeur associée à la clé spécifiée. Renvoienull
si la clé n'est pas trouvée.getOrDefault()
- Renvoie la valeur associée à la clé spécifiée. Renvoie la valeur par défaut spécifiée si la clé n'est pas trouvée.
Par exemple,
import java.util.concurrent.ConcurrentHashMap; class Main ( public static void main(String() args) ( ConcurrentHashMap numbers = new ConcurrentHashMap(); numbers.put("One", 1); numbers.put("Two", 2); numbers.put("Three", 3); System.out.println("ConcurrentHashMap: " + numbers); // Using get() int value1 = numbers.get("Three"); System.out.println("Using get(): " + value1); // Using getOrDefault() int value2 = numbers.getOrDefault("Five", 5); System.out.println("Using getOrDefault(): " + value2); ) )
Production
ConcurrentHashMap: (One = 1, Two = 2, Three = 3) Utilisation de get (): 3 Utilisation de getOrDefault (): 5
Supprimer les éléments ConcurrentHashMap
remove(key)
- renvoie et supprime l'entrée associée à la clé spécifiée de la carteremove(key, value)
- removes the entry from the map only if the specified key mapped to the specified value and return a boolean value
For example,
import java.util.concurrent.ConcurrentHashMap; class Main ( public static void main(String() args) ( ConcurrentHashMap numbers = new ConcurrentHashMap(); numbers.put("One", 1); numbers.put("Two", 2); numbers.put("Three", 3); System.out.println("ConcurrentHashMap: " + numbers); // remove method with single parameter int value = numbers.remove("Two"); System.out.println("Removed value: " + value); // remove method with two parameters boolean result = numbers.remove("Three", 3); System.out.println("Is the entry (Three=3) removed? " + result); System.out.println("Updated ConcurrentHashMap: " + numbers); ) )
Output
ConcurrentHashMap: (One=1, Two=2, Three=3) Removed value: 2 Is the entry (Three=3) removed? True Updated ConcurrentHashMap: (One=1)
Bulk ConcurrentHashMap Operations
The ConcurrentHashMap
class provides different bulk operations that can be applied safely to concurrent maps.
1. forEach() Method
The forEach()
method iterates over our entries and executes the specified function.
It includes two parameters.
- parallelismThreshold - It specifies that after how many elements operations in a map are executed in parallel.
- transformer - This will transform the data before the data is passed to the specified function.
For example,
import java.util.concurrent.ConcurrentHashMap; class Main ( public static void main(String() args) ( ConcurrentHashMap numbers = new ConcurrentHashMap(); numbers.put("One", 1); numbers.put("Two", 2); numbers.put("Three", 3); System.out.println("ConcurrentHashMap: " + numbers); // forEach() without transformer function numbers.forEach(4, (k, v) -> System.out.println("key: " + k + " value: " + v)); // forEach() with transformer function System.out.print("Values are "); numbers.forEach(4, (k, v) -> v, (v) -> System.out.print(v + ", ")); ) )
Output
ConcurrentHashMap: (One = 1, Two = 2, Three = 3) key: One value: 1 key: Two value: 2 key: Three value: 3 Values are 1, 2, 3,
In the above program, we have used parallel threshold 4. This means if the map contains 4 entries, the operation will be executed in parallel.
Variation of forEach() Method
forEachEntry()
- executes the specified function for each entryforEachKey()
- executes the specified function for each keyforEachValue()
- executes the specified function for each value
2. search() Method
The search()
method searches the map based on the specified function and returns the matched entry.
Here, the specified function determines what entry is to be searched.
It also includes an optional parameter parallelThreshold. The parallel threshold specifies that after how many elements in the map the operation is executed in parallel.
For example,
import java.util.concurrent.ConcurrentHashMap; class Main ( public static void main(String() args) ( ConcurrentHashMap numbers = new ConcurrentHashMap(); numbers.put("One", 1); numbers.put("Two", 2); numbers.put("Three", 3); System.out.println("ConcurrentHashMap: " + numbers); // Using search() String key = numbers.search(4, (k, v) -> (return v == 3 ? k: null;)); System.out.println("Searched value: " + key); ) )
Output
ConcurrentHashMap: (One=1, Two=2, Three=3) Searched value: Three
Variants of search() Method
searchEntries()
- search function is applied to key/value mappingssearchKeys()
- search function is only applied to the keyssearchValues()
- search function is only applied to the values
3. reduce() Method
The reduce()
method accumulates (gather together) each entry in a map. This can be used when we need all the entries to perform a common task, like adding all the values of a map.
It includes two parameters.
- parallelismThreshold - It specifies that after how many elements, operations in a map are executed in parallel.
- transformer - This will transform the data before the data is passed to the specified function.
For example,
import java.util.concurrent.ConcurrentHashMap; class Main ( public static void main(String() args) ( ConcurrentHashMap numbers = new ConcurrentHashMap(); numbers.put("One", 1); numbers.put("Two", 2); numbers.put("Three", 3); System.out.println("ConcurrentHashMap: " + numbers); // Using search() int sum = numbers.reduce(4, (k, v) -> v, (v1, v2) -> v1 + v2); System.out.println("Sum of all values: " + sum); ) )
Output
ConcurrentHashMap: (One=1, Two=2, Three=3) Sum of all values: 6
In the above program, notice the statement
numbers.reduce(4, (k, v) -> v, (v1, v2) -> v1+v2);
Here,
- 4 is a parallel threshold
- (k, v) -> v is a transformer function. It transfers the key/value mappings into values only.
- (v1, v2) -> v1+v2 is a reducer function. It gathers together all the values and adds all values.
Variants of reduce() Method
reduceEntries()
- returns the result of gathering all the entries using the specified reducer functionreduceKeys()
- returns the result of gathering all the keys using the specified reducer functionreduceValues()
- returns the result of gathering all the values using the specified reducer function
ConcurrentHashMap vs HashMap
Here are some of the differences between ConcurrentHashMap
and HashMap,
ConcurrentHashMap
is a thread-safe collection. That is, multiple threads can access and modify it at the same time.ConcurrentHashMap
provides methods for bulk operations likeforEach()
,search()
andreduce()
.
Why ConcurrentHashMap?
- La
ConcurrentHashMap
classe permet à plusieurs threads d'accéder à ses entrées simultanément. - Par défaut, la carte de hachage simultanée est divisée en 16 segments . C'est la raison pour laquelle 16 threads sont autorisés à modifier simultanément la carte en même temps. Cependant, n'importe quel nombre de threads peut accéder à la carte à la fois.
- La
putIfAbsent()
méthode ne remplacera pas l'entrée dans la carte si la clé spécifiée existe déjà. - Il fournit sa propre synchronisation.