Concurrence Java - Interface ConcurrentMap

Une interface java.util.concurrent.ConcurrentMap est une sous-interface de l'interface Map, prend en charge les opérations atomiques sur la variable de carte sous-jacente. Il a des méthodes get et set qui fonctionnent comme des lectures et des écritures sur des variables volatiles. Autrement dit, un ensemble a une relation qui se produit avant avec tout get ultérieur sur la même variable. Cette interface garantit la sécurité des fils et les garanties d'atomicité.

Méthodes ConcurrentMap

N ° Sr.	Méthode et description
1	default V compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) Tente de calculer un mappage pour la clé spécifiée et sa valeur mappée actuelle (ou null s'il n'y a pas de mappage actuel).
2	default V computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction) Si la clé spécifiée n'est pas déjà associée à une valeur (ou est mappée à null), tente de calculer sa valeur à l'aide de la fonction de mappage donnée et la saisit dans cette mappe à moins qu'elle ne soit nulle.
3	default V computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) Si la valeur de la clé spécifiée est présente et non nulle, tente de calculer un nouveau mappage en fonction de la clé et de sa valeur mappée actuelle.
4	default void forEach(BiConsumer<? super K,? super V> action) Exécute l'action donnée pour chaque entrée de cette mappe jusqu'à ce que toutes les entrées aient été traitées ou que l'action lève une exception.
5	default V getOrDefault(Object key, V defaultValue) Renvoie la valeur à laquelle la clé spécifiée est mappée, ou defaultValue si cette mappe ne contient aucun mappage pour la clé.
6	default V merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction) Si la clé spécifiée n'est pas déjà associée à une valeur ou est associée à null, l'associe à la valeur non nulle donnée.
sept	V putIfAbsent(K key, V value) Si la clé spécifiée n'est pas déjà associée à une valeur, associez-la à la valeur donnée.
8	boolean remove(Object key, Object value) Supprime l'entrée d'une clé uniquement si elle est actuellement mappée à une valeur donnée.
9	V replace(K key, V value) Remplace l'entrée d'une clé uniquement si elle est actuellement mappée à une valeur.
dix	boolean replace(K key, V oldValue, V newValue) Remplace l'entrée d'une clé uniquement si elle est actuellement mappée à une valeur donnée.
11	default void replaceAll(BiFunction<? super K,? super V,? extends V> function) Remplace la valeur de chaque entrée par le résultat de l'appel de la fonction donnée sur cette entrée jusqu'à ce que toutes les entrées aient été traitées ou que la fonction lève une exception.

Exemple

Le programme TestThread suivant montre l'utilisation de ConcurrentMap vs HashMap.

import java.util.ConcurrentModificationException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class TestThread {

   public static void main(final String[] arguments) {
      Map<String,String> map = new ConcurrentHashMap<String, String>();

      map.put("1", "One");
      map.put("2", "Two");
      map.put("3", "Three");
      map.put("5", "Five");
      map.put("6", "Six");

      System.out.println("Initial ConcurrentHashMap: " + map);
      Iterator<String> iterator = map.keySet().iterator();

      try { 
         
         while(iterator.hasNext()) {
            String key = iterator.next();
            
            if(key.equals("3")) {
               map.put("4", "Four");
            }
         }
      } catch(ConcurrentModificationException cme) {
         cme.printStackTrace();
      }
      System.out.println("ConcurrentHashMap after modification: " + map);

      map = new HashMap<String, String>();

      map.put("1", "One");
      map.put("2", "Two");
      map.put("3", "Three");
      map.put("5", "Five");
      map.put("6", "Six");

      System.out.println("Initial HashMap: " + map);
      iterator = map.keySet().iterator();

      try {
         
         while(iterator.hasNext()) {
            String key = iterator.next();
            
            if(key.equals("3")) {
               map.put("4", "Four");
            }
         }
         System.out.println("HashMap after modification: " + map);
      } catch(ConcurrentModificationException cme) {
         cme.printStackTrace();
      }
   }  
}

Cela produira le résultat suivant.

Production

Initial ConcurrentHashMap: {1 = One, 2 = Two, 3 = Three, 5 = Five, 6 = Six}
ConcurrentHashMap after modification: {1 = One, 2 = Two, 3 = Three, 4 = Four, 5 = Five, 6 = Six}
Initial HashMap: {1 = One, 2 = Two, 3 = Three, 5 = Five, 6 = Six}
java.util.ConcurrentModificationException
	at java.util.HashMap$HashIterator.nextNode(Unknown Source)
	at java.util.HashMap$KeyIterator.next(Unknown Source)
	at TestThread.main(TestThread.java:48)