Java ConcurrentHashMap

在本教程中，我们将借助示例学习Java ConcurrentHashMap类及其操作。

Java集合框架的ConcurrentHashMap类提供了线程安全的映射。 也就是说，多个线程可以一次访问该映射，而不会影响映射中条目的一致性。

它继承了ConcurrentMap接口。

创建一个ConcurrentHashMap

为了创建并发的哈希图，我们必须先导入java.util.concurrent.ConcurrentHashMap包。导入包后，就可以在Java中创建并发哈希映射。

//ConcurrentHashMap具有容量8和负载因子0.6
ConcurrentHashMap<Key, Value> numbers = new ConcurrentHashMap<>(8, 0.6f);

在上面的代码中，我们创建了一个名为numbers的并发哈希映射。

ici,

• Clé - 用于关联map中每个元素（值）的唯一标识符

• Value - map中与键相关联的元素

注意语句 new ConcurrentHashMap<>(8, 0.6)。在这里，第一个参数是capacity，第二个参数是loadFactor。

• capacity -该映射的容量为8。意味着，它可以存储8个条目。

• loadFactor-此map的负载因子为0.6。这意味着，只要我们的哈希表填充了60％，条目就会移到新哈希表中，其大小是原始哈希表的两倍。

默认容量和负载因子

无需定义其容量和负载因子就可以创建并发哈希图。例如，

//　具有默认容量和负载因子的ConcurrentHashMap
ConcurrentHashMap<Key, Value> numbers1　= new ConcurrentHashMap<>();

Par défaut,

• La capacité de la map sera 16

• Le facteur de charge sera 0.75

Création de ConcurrentHashMap à partir d'une autre carte

Voici comment nous créons un ConcurrentHashMap contenant tous les éléments d'une autre carte.

import　java.util.concurrent.ConcurrentHashMap;
import java.util.HashMap;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//　Création d'un HashMap pair
　　　　　　　　HashMap<String, Integer> evenNumbers = new HashMap<>();
　　　　　　　　evenNumbers.put("Two",　2);
　　　　　　　　evenNumbers.put("Four",　4);
　　　　　　　　System.out.println("HashMap: ",　+　evenNumbers);
　　　　　　　　//Création d'un ConcurrentHashMap à partir d'une autre carte
　　　　　　　　ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>(evenNumbers);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("ConcurrentHashMap:　"　+　numbers);
　　　　}
}

Résultat de la sortie

HashMap: {Four=4,　Two=2}
ConcurrentHashMap: {Four=4,　Two=2,　Three=3}

Les méthodes de ConcurrentHashMap

La classe ConcurrentHashMap fournit des méthodes permettant d'exécuter diverses opérations sur les cartes.

Insérer l'élément dans ConcurrentHashMap

• put() - Insérer la clé spécifiée/Insérer les valeurs de la carte dans la carte

• putAll() - Insérer tous les éléments de la carte spécifiée dans cette map

• putIfAbsent() - Si la carte ne contient pas la clé spécifiée, insérer la clé spécifiée/Les valeurs de la carte insérées dans la map

par exemple,

import　java.util.concurrent.ConcurrentHashMap;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//Création d'un ConcurrentHashMap pair
　　　　　　　　ConcurrentHashMap<String, Integer> evenNumbers = new ConcurrentHashMap<>();
　　　　　　　　//　Utilisation de put()
　　　　　　　　evenNumbers.put("Two",　2);
　　　　　　　　evenNumbers.put("Four",　4);
　　　　　　　　//　Utilisation de putIfAbsent()
　　　　　　　　evenNumbers.putIfAbsent("Six",　6);
　　　　　　　　System.out.println("Le ConcurrentHashMap pair: ",　+　evenNumbers);
　　　　　　　　//Création d'un ConcurrentHashMap des nombres
　　　　　　　　ConcurrentHashMap<String,　Integer>　numbers　=　new　ConcurrentHashMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　//　Utilisation de putAll()
　　　　　　　　numbers.putAll(evenNumbers);
　　　　　　　　System.out.println("Le ConcurrentHashMap des nombres: ",　+　numbers);
　　　　}
}

Résultat de la sortie

Le ConcurrentHashMap pair: {Six=6, Four=4,　Two=2}
Les nombres de ConcurrentHashMap sont: {Six=6, One=1, Four=-4,　Two=2}

accès aux éléments de ConcurrentHashMap

1.en utilisant entrySet(), keySet() et values()

• entrySet() - retourne un ensemble de toutes les clés/ensemble des mappings des valeurs

• keySet() - retourne l'ensemble de toutes les clés de la carte

• values() - retourne l'ensemble de toutes les valeurs de la carte

par exemple,

import　java.util.concurrent.ConcurrentHashMap;
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);
　　　　　　　　System.out.println("ConcurrentHashMap:　"　+　numbers);
　　　　　　　　//　en utilisant entrySet()
　　　　　　　　System.out.println("Clé/Mapping des valeurs:　+　numbers.entrySet());
　　　　　　　　//　en utilisant keySet()
　　　　　　　　System.out.println("Clés: ")　+　numbers.keySet());
　　　　　　　　//　en utilisant values()
　　　　　　　　System.out.println("Valeurs: ")　+　numbers.values());
　　　　}
}

Résultat de la sortie

ConcurrentHashMap:　{One=1,　Two=2,　Three=3}
Clé/Mapping des valeurs:1,　Two=2,　Three=3]
Clés: [One, Two, Three]
Valeurs:1,　2,　3]

2.en utilisant get() et getOrDefault()

• get() - retourne la valeur associée à la clé spécifiée. Si la clé n'est pas trouvée, elle renvoie null.

• getOrDefault() - retourne la valeur associée à la clé spécifiée. Si la clé n'est pas trouvée, elle renvoie la valeur par défaut spécifiée.

par exemple,

import　java.util.concurrent.ConcurrentHashMap;
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);
　　　　　　　　System.out.println("ConcurrentHashMap:　"　+　numbers);
　　　　　　　　//　en utilisant get()
　　　　　　　　int value1　= numbers.get("Three");
　　　　　　　　System.out.println("En utilisant get(): "　+　value1);
　　　　　　　　//　en utilisant getOrDefault()
　　　　　　　　int value2　= numbers.getOrDefault("Five",　5);
　　　　　　　　System.out.println("En utilisant getOrDefault(): "　+　value2);
　　　　}
}

Résultat de la sortie

ConcurrentHashMap:　{One=1,　Two=2,　Three=3}
en utilisant get():　3
en utilisant getOrDefault():　5

suppression des éléments de ConcurrentHashMap

• remove(key) - retourne et supprime l'entrée associée à la clé spécifiée dans la carte

• remove(key, value) - supprime l'entrée de la carte uniquement si la clé correspond à la valeur spécifiée et renvoie une valeur booléenne

par exemple,

import　java.util.concurrent.ConcurrentHashMap;
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);
　　　　　　　　System.out.println("ConcurrentHashMap:　"　+　numbers);
　　　　　　　　//méthode de suppression avec un paramètre
　　　　　　　　int value = numbers.remove("Two");
　　　　　　　　System.out.println("Valeur supprimée: "　+　value);
　　　　　　　　//　méthode de suppression avec deux paramètres
　　　　　　　　boolean result = numbers.remove("Three",　3);
　　　　　　　　System.out.println("Entrée {Trois=3} a-t-il été supprimé? "　+　result);
　　　　　　　　System.out.println("ConcurrentHashMap mis à jour: ",　+　numbers);
　　　　}
}

Résultat de la sortie

ConcurrentHashMap:　{One=1,　Two=2,　Three=3}
Valeur supprimée:　2
Entrée {Trois=3} a-t-il été supprimé? True
ConcurrentHashMap mis à jour: {Un=1}

Méthodes de batch opérations de ConcurrentHashMap

La classe ConcurrentHashMap fournit des méthodes de batch opérations différentes qui peuvent être appliquées en toute sécurité en parallèle à des maps.

1. méthode forEach()

La méthode forEach() parcourt nos entrées et exécute la fonction spécifiée.

elle contient deux paramètres.

• parallelismThreshold -Il spécifie après combien d'éléments de la carte l'opération doit être exécutée en parallèle.

• transformer -Cela convertira les données avant de les transmettre à la fonction spécifiée.

par exemple,

import　java.util.concurrent.ConcurrentHashMap;
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);
　　　　　　　　System.out.println("ConcurrentHashMap:　"　+　numbers);
　　　　　　　　//forEach() ne contient pas la fonction transmise
　　　　　　　　numbers.forEach(4,　(k,　v)　-> System.out.println("clé: ",　+　k　+　" valeur: "　+　v));
　　　　　　　　//　forEach() transmet la fonction spécifiée
　　　　　　　　System.out.print("Les valeurs sont ");
　　　　　　　　numbers.forEach(4,　(k,　v)　-> v, (v)　-> System.out.print(v　+　, ");
　　　　}
}

Résultat de la sortie

ConcurrentHashMap: {Un =　1, Deux =　2, Trois =　3}
clé: Un valeur:　1
clé: Deux valeur:　2
clé: Trois valeur:　3
Les valeurs sont　1,　2,　3,

Dans le programme ci-dessus, nous avons utilisé le seuil de parallélisation4. Cela signifie que si la carte contient4opérations si il y a plusieurs entrées, cette opération sera exécutée en parallèle.

Variante de la méthode forEach()

• forEachEntry() - Exécute la fonction spécifiée pour chaque entrée

• forEachKey() - Exécute la fonction spécifiée pour chaque clé

• forEachValue() - Exécute la fonction spécifiée pour chaque valeur

2. search() méthode

La méthode search() recherche dans la carte en fonction de la fonction spécifiée et retourne l'entrée correspondante.

Ici, la fonction spécifiée détermine ce que recherche la recherche.

Il contient également un paramètre optionnel parallelThreshold. Ce seuil de parallélisation spécifie après combien d'éléments de la carte l'opération doit être exécutée en parallèle.

par exemple,

import　java.util.concurrent.ConcurrentHashMap;
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);
　　　　　　　　System.out.println("ConcurrentHashMap:　"　+　numbers);
　　　　　　　　//　en utilisant search()
　　　　　　　　String key = numbers.search(4,　(k,　v)　-> {return v ==　3　? k: null;});
　　　　　　　　System.out.println("Valeur recherchée: ",　+　key);
　　　　}
}

Résultat de la sortie

ConcurrentHashMap:　{One=1,　Two=2,　Three=3}
valeur recherchée:　Three

variantes de la méthode search()

• searchEntries() - La fonction de recherche s'applique aux clés/carte des valeurs

• searchKeys() - La fonction de recherche s'applique uniquement aux clés

• searchValues() - La fonction de recherche s'applique uniquement aux valeurs

3. méthode reduce()

La méthode reduce() accumule (aggrave) chaque entrée de la carte.

elle contient deux paramètres.

• parallelismThreshold -il spécifie après combien d'éléments l'opération dans la carte sera exécutée en parallèle.

• transformer - ceci convertira les données avant de les transmettre à la fonction spécifiée.

par exemple,

import　java.util.concurrent.ConcurrentHashMap;
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);
　　　　　　　　System.out.println("ConcurrentHashMap:　"　+　numbers);
　　　　　　　　//　en utilisant search()
　　　　　　　　int　sum　=　numbers.reduce(4,　(k,　v)　->　v,　(v1,　v2)　->　v1　+　v2);
　　　　　　　　System.out.println("La somme de toutes les valeurs:　"　+　sum);
　　　　}
}

Résultat de la sortie

ConcurrentHashMap:　{One=1,　Two=2,　Three=3}
La somme de toutes les valeurs:　6

Dans le programme ci-dessus, veuillez noter les instructions suivantes

numbers.reduce(4,　(k,　v)　->　v,　(v1,　v2)　->　v1+v2);

ici,

• 4 est un seuil de parallélisme

• (k, v) -> v est une fonction de transformation. Elle transforme les clés/la carte des valeurs ne se convertit qu'en valeurs.

• (v1, v2) -> v1+v2 est une fonction de calcul de taille. Elle collecte toutes les valeurs et les ajoute ensemble.

une variante de la méthode reduce()

• reduceEntries() - retourne les résultats collectés par la fonction reducer spécifiée pour toutes les entrées

• reduceKeys() - retourne les résultats collectés par la fonction reducer spécifiée pour toutes les clés

• reduceValues() - Return the result of collecting all values using the specified reducer function

The difference between ConcurrentHashMap and HashMap

The following is ConcurrentHashMap andHashMapSome differences between

• ConcurrentHashMap isthread-safecollection. That is, multiple threads can access and modify it at the same time.

• ConcurrentHashMap provides methods for batch operations such as forEach(), search(), and reduce().

Why choose ConcurrentHashMap?

• The ConcurrentHashMap class allows multiple threads to perform concurrent modification operations.

• By default, concurrent hash maps are divided16section. That is why it is allowed16The reason for multiple threads to modify the map at the same time is that any number of threads can access it at one time.

• The putIfAbsent() method will not overwrite the entry in the map if the specified key already exists.