Método de computación ConcurrentHashMap() en Java con ejemplos

El método compute(Key, BiFunction) de la clase ConcurrentHashMap se usa para calcular una asignación para la clave especificada y su valor asignado actual (o nulo si no se encuentra ninguna asignación actual).

• Este método se usa para actualizar atómicamente un valor para una clave determinada en ConcurrentHashMap.
• Si la función de reasignación arroja una excepción, la excepción se vuelve a generar y la asignación actual permanece sin cambios.
• Durante el cálculo, se bloqueó el proceso de actualización en este mapa desde otros subprocesos, por lo que el cálculo no debe intentar actualizar ninguna otra asignación de este mapa.
• Por ejemplo, esta asignación agrega el valor de string de la asignación:

ConcurrentHashMap.compute(key, 
(key, value) -> (value == null) ? msg : value.concat(msg))

Sintaxis:

public V 
       compute(K key,
               BiFunction<? super K, ? super V, 
                  ? extends V> remappingFunction)

Parámetros: Este método acepta dos parámetros:

• key : clave con la que se va a asociar el valor.
• remappingFunction : función para realizar la operación sobre el valor.

Devoluciones: este método devuelve un nuevo valor asociado con la clave especificada, o nulo si no hay ninguno . Excepción: este método arroja las siguientes excepciones:

• NullPointerException: si la clave especificada o función de reasignación es nula.
• IlegalStateException: si el cálculo intenta realizar una actualización recursiva de este mapa que, de otro modo, nunca se completaría.
• RuntimeException: si la función de reasignación lo hace, en cuyo caso la asignación no cambia.

Los siguientes programas ilustran el método de cálculo (clave, bifunción): Programa 1: 

// Java program to demonstrate
// compute(Key, BiFunction) method.
 
import java.util.concurrent.*;
 
public class GFG {
 
    // Main method
    public static void main(String[] args)
    {
 
        // create a ConcurrentHashMap and add some values
        ConcurrentHashMap<String, Integer>
            map = new ConcurrentHashMap<>();
        map.put("Book1", 10);
        map.put("Book2", 500);
        map.put("Book3", 400);
 
        // print map details
        System.out.println("ConcurrentHashMap: "
                           + map.toString());
 
        // remap the values of ConcurrentHashMap
        // using compute method
        map.compute("Book2", (key, val)
                                 -> val + 100);
        map.compute("Book1", (key, val)
                                 -> val + 512);
 
        // print new mapping
        System.out.println("New ConcurrentHashMap: "
                           + map);
    }
}

ConcurrentHashMap: {Book3=400, Book1=10, Book2=500}
New ConcurrentHashMap: {Book3=400, Book1=522, Book2=600}

Programa 2: 

// Java program to demonstrate
// compute(Key, BiFunction) method.
 
import java.util.concurrent.*;
 
public class GFG {
 
    // Main method
    public static void main(String[] args)
    {
 
        // create a ConcurrentHashMap and add some values
        ConcurrentHashMap<Integer, String>
            map = new ConcurrentHashMap<>();
        map.put(1, "Kolkata");
        map.put(2, "Nadia");
        map.put(3, "Howrah");
 
        // print map details
        System.out.println("ConcurrentHashMap: "
                           + map.toString());
 
        // remap the values of ConcurrentHashMap
        // using compute method
        map.compute(2, (key, val)
                           -> val.concat(" (West-Bengal)"));
        map.compute(3, (key, val)
                           -> val.concat(" (West-Bengal)"));
 
        // print new mapping
        System.out.println("New ConcurrentHashMap: "
                           + map);
    }
}

ConcurrentHashMap: {1=Kolkata, 2=Nadia, 3=Howrah}
New ConcurrentHashMap: {1=Kolkata, 2=Nadia (West-Bengal), 3=Howrah (West-Bengal)}

Programa 3: Para mostrar NullPointerException 

// Java program to demonstrate NullPointerException
// for compute(Key, BiFunction) method.
 
import java.util.concurrent.*;
 
public class GFG {
 
    // Main method
    public static void main(String[] args)
    {
 
        // create a ConcurrentHashMap and add some values
        ConcurrentHashMap<Integer, String>
            map = new ConcurrentHashMap<>();
        map.put(1, "Kolkata");
        map.put(2, "Nadia");
        map.put(3, "Howrah");
 
        try {
 
            // remap the values of ConcurrentHashMap
            // using compute method
            map.compute(null, (key, val)
                                  -> val.concat(" (West-Bengal)"));
        }
        catch (NullPointerException e) {
 
            // print Exception
            System.out.println("Exception: " + e);
        }
    }
}

Exception: java.lang.NullPointerException

Referencias: https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ConcurrentHashMap.html#compute-K-java.util.function.BiFunction-