Interfaz de mapa concurrente en java

ConcurrentMap es una interfaz y es miembro de Java Collections Framework , que se introdujo en JDK 1.5 y representa un mapa que es capaz de manejar el acceso simultáneo sin afectar la consistencia de las entradas en un mapa. Interfaz ConcurrentMap presente en el paquete java.util.concurrent . Proporciona algunos métodos adicionales además de lo que hereda de SuperInterface, es decir, java.util.Map . Ha heredado el Map.Entry de interfaz anidada<K, V> . 

Las operaciones de HashMap no están sincronizadas, mientras que Hashtable proporciona sincronización. Aunque Hashtable es seguro para subprocesos, no es muy eficiente. Para resolver este problema, Java Collections Framework introdujo ConcurrentMap en Java 1.5.

La jerarquía de ConcurrentMap
 

Declaración:

public interface ConcurrentMap<K,V> extends Map<K,V>

Aquí, K es el tipo de objeto clave y V es el tipo de objeto de valor.

• Extiende la interfaz Map en Java .
• ConcurrentNavigableMap<K,V> es la subinterfaz.
• ConcurrentMap se implementa mediante las clases ConcurrentHashMap y ConcurrentSkipListMap .
• ConcurrentMap se conoce como un mapa sincronizado.

Implementando Clases

Como pertenece al paquete java.util.concurrent , debemos importarlo usando

import java.util.concurrent.ConcurrentMap
                or
import java.util.concurrent.*

El ConcurrentMap tiene dos clases de implementación que son ConcurrentSkipListMap y ConcurrentHashMap . ConcurrentSkipListMap es una implementación escalable de la interfaz ConcurrentNavigableMap que amplía la interfaz ConcurrentMap. Las claves en ConcurrentSkipListMap se clasifican por orden natural o mediante el uso de un comparador en el momento de la construcción del objeto. El ConcurrentSkipListMap tiene el costo de tiempo esperado de log(n) para las operaciones de inserción, eliminación y búsqueda. Es una clase segura para subprocesos, por lo tanto, todas las operaciones básicas se pueden realizar al mismo tiempo.

Sintaxis:

// ConcurrentMap implementation by ConcurrentHashMap
CocurrentMap<K, V> numbers = new ConcurrentHashMap<K, V>();

// ConcurrentMap implementation by ConcurrentSkipListMap
ConcurrentMap< ? , ? > objectName = new ConcurrentSkipListMap< ? , ? >();

Ejemplo:
 

// Java Program to illustrate methods
// of ConcurrentMap interface
import java.util.concurrent.*;
  
class ConcurrentMapDemo {
  
    public static void main(String[] args)
    {
        // Since ConcurrentMap is an interface,
        // we create instance using ConcurrentHashMap
        ConcurrentMap<Integer, String> m = new ConcurrentHashMap<Integer, String>();
        m.put(100, "Geeks");
        m.put(101, "For");
        m.put(102, "Geeks");
  
        // Here we cant add Hello because 101 key
        // is already present
        m.putIfAbsent(101, "Hello");
  
        // We can remove entry because 101 key
        // is associated with For value
        m.remove(101, "For");
  
        // Now we can add Hello
        m.putIfAbsent(101, "Hello");
  
        // We can replace Hello with For
        m.replace(101, "Hello", "For");
        System.out.println("Map contents : " + m);
    }
}

Map contents : {100=Geeks, 101=For, 102=Geeks}

Métodos básicos

1. Agregar elementos

El método put() de ConcurrentSkipListMap es una función integrada en Java que asocia el valor especificado con la clave especificada en este mapa. Si el mapa contenía anteriormente una asignación para la clave, se reemplaza el valor anterior.

// Java Program to demonstrate adding
// elements
  
import java.util.concurrent.*;
  
class AddingElementsExample {
    public static void main(String[] args)
    {
        // Instantiate an object
        // Since ConcurrentMap
        // is an interface so We use
        // ConcurrentSkipListMap
        ConcurrentMap<Integer, Integer> mpp = new ConcurrentSkipListMap<Integer, Integer>();
  
        // Adding elements to this map
          // using put() method
        for (int i = 1; i <= 5; i++)
            mpp.put(i, i);
  
        // Print map to the console
        System.out.println("After put(): " + mpp);
    }
}

After put(): {1=1, 2=2, 3=3, 4=4, 5=5}

2. Eliminar elementos

El método remove() de ConcurrentSkipListMap es una función integrada en Java que elimina la asignación de la clave especificada de esta asignación. El método devuelve nulo si no hay una asignación para esa clave en particular. Después de realizar este método, se reduce el tamaño del mapa.

// Java Program to demonstrate removing
// elements
  
import java.util.concurrent.*;
  
class RemovingElementsExample {
    public static void main(String[] args)
    {
        // Instantiate an object
        // Since ConcurrentMap
        // is an interface so We use
        // ConcurrentSkipListMap
        ConcurrentMap<Integer, Integer> mpp = new ConcurrentSkipListMap<Integer, Integer>();
  
        // Adding elements to this map
        // using put method
        for (int i = 1; i <= 5; i++)
            mpp.put(i, i);
  
        // remove() mapping associated
        // with key 1
        mpp.remove(1);
  
        System.out.println("After remove(): " + mpp);
    }
}

After remove(): {2=2, 3=3, 4=4, 5=5}

3. Accediendo a los Elementos

Podemos acceder a los elementos de un ConcurrentSkipListMap usando el método get(), el ejemplo de esto se da a continuación.

// Java Program to demonstrate accessing
// elements
  
import java.util.concurrent.*;
  
class AccessingElementsExample {
  
    public static void main(String[] args)
    {
  
        // Instantiate an object
        // Since ConcurrentMap
        // is an interface so We use
        // ConcurrentSkipListMap
        ConcurrentMap<Integer, String> chm = new ConcurrentSkipListMap<Integer, String>();
  
        // insert mappings using put method
        chm.put(100, "Geeks");
        chm.put(101, "for");
        chm.put(102, "Geeks");
        chm.put(103, "Contribute");
  
        // Displaying the HashMap
        System.out.println("The Mappings are: ");
        System.out.println(chm);
  
        // Display the value of 100
        System.out.println("The Value associated to "
                           + "100 is : " + chm.get(100));
  
        // Getting the value of 103
        System.out.println("The Value associated to "
                           + "103 is : " + chm.get(103));
    }
}

The Mappings are: 
{100=Geeks, 101=for, 102=Geeks, 103=Contribute}
The Value associated to 100 is : Geeks
The Value associated to 103 is : Contribute

4. Atravesando

Podemos usar la interfaz Iterator para atravesar cualquier estructura del marco de colección. Dado que los iteradores trabajan con un tipo de datos, usamos Entry< ? , ? > para resolver los dos tipos separados en un formato compatible. Luego, usando el método next() imprimimos los elementos del ConcurrentSkipListMap.

import java.util.concurrent.*;
import java.util.*;
  
public class TraversingExample {
  
    public static void main(String[] args)
    {
  
        // Instantiate an object
        // Since ConcurrentMap
        // is an interface so We use
        // ConcurrentSkipListMap
        ConcurrentMap<Integer, String> chmap = new ConcurrentSkipListMap<Integer, String>();
  
        // Add elements using put()
        chmap.put(8, "Third");
        chmap.put(6, "Second");
        chmap.put(3, "First");
        chmap.put(11, "Fourth");
  
        // Create an Iterator over the
        // ConcurrentSkipListMap
        Iterator<ConcurrentSkipListMap
                     .Entry<Integer, String> > itr
            = chmap.entrySet().iterator();
  
        // The hasNext() method is used to check if there is
        // a next element The next() method is used to
        // retrieve the next element
        while (itr.hasNext()) {
            ConcurrentSkipListMap
                .Entry<Integer, String> entry
                = itr.next();
            System.out.println("Key = " + entry.getKey()
                               + ", Value = "
                               + entry.getValue());
        }
    }
}

Key = 3, Value = First
Key = 6, Value = Second
Key = 8, Value = Third
Key = 11, Value = Fourth

Métodos de ConcurrentMap

• K – El tipo de claves en el mapa.
• V – El tipo de valores mapeados en el mapa.

Métodos heredados de la interfaz java.util.Map

Referencia: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ConcurrentMap.html