Simultaneidade Java - Interface ConcurrentMap

Uma interface java.util.concurrent.ConcurrentMap é uma subinterface da interface Map, oferece suporte a operações atômicas na variável de mapa subjacente. Ele possui métodos get e set que funcionam como leituras e gravações em variáveis ​​voláteis. Ou seja, um conjunto tem um relacionamento acontece antes com qualquer obtenção subsequente na mesma variável. Esta interface garante segurança de thread e garantias de atomicidade.

Métodos ConcurrentMap

Sr. Não.	Método e Descrição
1	default V compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) Tenta calcular um mapeamento para a chave especificada e seu valor mapeado atual (ou nulo se não houver mapeamento atual).
2	default V computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction) Se a chave especificada ainda não estiver associada a um valor (ou estiver mapeada para nulo), tenta calcular seu valor usando a função de mapeamento fornecida e o insere no mapa, a menos que seja nulo.
3	default V computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) Se o valor da chave especificada estiver presente e não for nulo, tenta calcular um novo mapeamento com base na chave e seu valor mapeado atual.
4	default void forEach(BiConsumer<? super K,? super V> action) Executa a ação fornecida para cada entrada neste mapa até que todas as entradas tenham sido processadas ou a ação lance uma exceção.
5	default V getOrDefault(Object key, V defaultValue) Retorna o valor para o qual a chave especificada é mapeada ou defaultValue se este mapa não contiver mapeamento para a chave.
6	default V merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction) Se a chave especificada ainda não estiver associada a um valor ou estiver associada a nulo, associa-a ao valor não nulo fornecido.
7	V putIfAbsent(K key, V value) Se a chave especificada ainda não estiver associada a um valor, associe-a ao valor fornecido.
8	boolean remove(Object key, Object value) Remove a entrada de uma chave apenas se atualmente mapeada para um determinado valor.
9	V replace(K key, V value) Substitui a entrada por uma chave apenas se atualmente mapeada para algum valor.
10	boolean replace(K key, V oldValue, V newValue) Substitui a entrada por uma chave apenas se atualmente mapeada para um determinado valor.
11	default void replaceAll(BiFunction<? super K,? super V,? extends V> function) Substitui o valor de cada entrada com o resultado da chamada da função fornecida nessa entrada até que todas as entradas tenham sido processadas ou a função lance uma exceção.

Exemplo

O programa TestThread a seguir mostra o uso de ConcurrentMap versus 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();
      }
   }  
}

Isso produzirá o seguinte resultado.

Resultado

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)