Header Ads Widget

Ticker

6/recent/ticker-posts

Java ConcurrentHashMap

En este tutorial, aprenderemos sobre la clase Java ConcurrentHashMap y sus operaciones con la ayuda de ejemplos.
anuncios a través de carbonoHola, nube de borde. Hasta luego, entrega lenta. Comience a probar ahora por $ 0.ANUNCIOS A TRAVÉS DE CARBONO
La ConcurrentHashMapclase del marco de colecciones de Java proporciona un mapa seguro para subprocesos. Es decir, múltiples hilos pueden acceder al mapa a la vez sin afectar la consistencia de las entradas en un mapa.
Implementa la interfaz ConcurrentMap .
La clase Java ConcurrentHashMap implementa la interfaz ConcurrentMap.

Crear un mapa de hash concurrente

Para crear un hashmap concurrente, primero debemos importar el java.util.concurrent.ConcurrentHashMappaquete. Una vez que importamos el paquete, así es como podemos crear hashmaps concurrentes en Java.
  1. // ConcurrentHashMap with capacity 8 and load factor 0.6
  2. ConcurrentHashMap<Key, Value> numbers = new ConcurrentHashMap<>(8, 0.6f);
En el código anterior, hemos creado un hashmap concurrente llamado números .
Aquí,
  • Clave : un identificador único utilizado para asociar cada elemento (valor) en un mapa
  • Valor : elementos asociados por claves en un mapa
Fíjate en la parte new ConcurrentHashMap<>(8, 0.6)Aquí, el primer parámetro es la capacidad y el segundo parámetro es loadFactor .
  • capacidad : la capacidad de este mapa es 8. Es decir, puede almacenar 8 entradas.
  • loadFactor : el factor de carga de este mapa es 0.6. Esto significa que cada vez que nuestra tabla hash se llena en un 60%, las entradas se mueven a una nueva tabla hash del doble del tamaño de la tabla hash original.
Capacidad predeterminada y factor de carga
Es posible crear un hashmap concurrente sin definir su capacidad y factor de carga. Por ejemplo,
  1. // ConcurrentHashMap with default capacity and load factor
  2. ConcurrentHashMap<Key, Value> numbers1 = new ConcurrentHashMap<>();
Por defecto,
  • la capacidad del mapa será de 16
  • el factor de carga será 0.75

Crear ConcurrentHashMap desde otros mapas

Aquí es cómo podemos crear un hashmap concurrente que contenga todos los elementos de otros mapas.
  1. import java.util.concurrent.ConcurrentHashMap;
  2. import java.util.HashMap;
  3. class Main {
  4. public static void main(String[] args) {
  5. // Creating a hashmap of even numbers
  6. HashMap<String, Integer> evenNumbers = new HashMap<>();
  7. evenNumbers.put("Two", 2);
  8. evenNumbers.put("Four", 4);
  9. System.out.println("HashMap: " + evenNumbers);
  10. // Creating a concurrent hashmap from other map
  11. ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>(evenNumbers);
  12. numbers.put("Three", 3);
  13. System.out.println("ConcurrentHashMap: " + numbers);
  14. }
  15. }
Salida
HashMap: {Cuatro = 4, Dos = 2}
ConcurrentHashMap: {Cuatro = 4, Dos = 2, Tres = 3}

Métodos de ConcurrentHashMap

La ConcurrentHashMapclase proporciona métodos que nos permiten realizar varias operaciones en el mapa.

Insertar elementos en ConcurrentHashMap

  • put() - inserta la asignación de clave / valor especificada en el mapa
  • putAll() - inserta todas las entradas del mapa especificado en este mapa
  • putIfAbsent() - inserta la asignación de clave / valor especificada en el mapa si la clave especificada no está presente en el mapa
Por ejemplo,
  1. import java.util.concurrent.ConcurrentHashMap;
  2. class Main {
  3. public static void main(String[] args) {
  4. // Creating ConcurrentHashMap of even numbers
  5. ConcurrentHashMap<String, Integer> evenNumbers = new ConcurrentHashMap<>();
  6. // Using put()
  7. evenNumbers.put("Two", 2);
  8. evenNumbers.put("Four", 4);
  9. // Using putIfAbsent()
  10. evenNumbers.putIfAbsent("Six", 6);
  11. System.out.println("ConcurrentHashMap of even numbers: " + evenNumbers);
  12. //Creating ConcurrentHashMap of numbers
  13. ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>();
  14. numbers.put("One", 1);
  15. // Using putAll()
  16. numbers.putAll(evenNumbers);
  17. System.out.println("ConcurrentHashMap of numbers: " + numbers);
  18. }
  19. }
Salida
ConcurrentHashMap de números pares: {Six = 6, Four = 4, Two = 2}
ConcurrentHashMap de números: {Six = 6, ONe = 1, Four = -4, Two = 2}

Acceda a elementos ConcurrentHashMap

1. Usando entrySet (), keySet () y values ​​()
  • entrySet() - devuelve un conjunto de todas las asignaciones de clave / valor del mapa
  • keySet() - devuelve un conjunto de todas las teclas del mapa
  • values() - devuelve un conjunto de todos los valores del mapa
Por ejemplo,
  1. import java.util.concurrent.ConcurrentHashMap;
  2. class Main {
  3. public static void main(String[] args) {
  4. ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>();
  5. numbers.put("One", 1);
  6. numbers.put("Two", 2);
  7. numbers.put("Three", 3);
  8. System.out.println("ConcurrentHashMap: " + numbers);
  9. // Using entrySet()
  10. System.out.println("Key/Value mappings: " + numbers.entrySet());
  11. // Using keySet()
  12. System.out.println("Keys: " + numbers.keySet());
  13. // Using values()
  14. System.out.println("Values: " + numbers.values());
  15. }
  16. }
Salida
ConcurrentHashMap: {Uno = 1, Dos = 2, Tres = 3}
Asignaciones de clave / valor: [Uno = 1, Dos = 2, Tres = 3]
Claves: [Uno, Dos, Tres]
Valores: [1, 2, 3]
2. Usando get () y getOrDefault ()
  • get()- Devuelve el valor asociado con la clave especificada. Devuelve nullsi no se encuentra la clave.
  • getOrDefault()- Devuelve el valor asociado con la clave especificada. Devuelve el valor predeterminado especificado si no se encuentra la clave.
Por ejemplo,
  1. import java.util.concurrent.ConcurrentHashMap;
  2. class Main {
  3. public static void main(String[] args) {
  4. ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>();
  5. numbers.put("One", 1);
  6. numbers.put("Two", 2);
  7. numbers.put("Three", 3);
  8. System.out.println("ConcurrentHashMap: " + numbers);
  9. // Using get()
  10. int value1 = numbers.get("Three");
  11. System.out.println("Using get(): " + value1);
  12. // Using getOrDefault()
  13. int value2 = numbers.getOrDefault("Five", 5);
  14. System.out.println("Using getOrDefault(): " + value2);
  15. }
  16. }
Salida
ConcurrentHashMap: {Uno = 1, Dos = 2, Tres = 3}
El uso de get (): 3
Usando getOrDefault (): 5

Eliminar elementos ConcurrentHashMap

  • remove(key) - devuelve y elimina la entrada asociada con la clave especificada del mapa
  • remove(key, value) - elimina la entrada del mapa solo si la clave especificada se asigna al valor especificado y devuelve un valor booleano
Por ejemplo,
  1. import java.util.concurrent.ConcurrentHashMap;
  2. class Main {
  3. public static void main(String[] args) {
  4. ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>();
  5. numbers.put("One", 1);
  6. numbers.put("Two", 2);
  7. numbers.put("Three", 3);
  8. System.out.println("ConcurrentHashMap: " + numbers);
  9. // remove method with single parameter
  10. int value = numbers.remove("Two");
  11. System.out.println("Removed value: " + value);
  12. // remove method with two parameters
  13. boolean result = numbers.remove("Three", 3);
  14. System.out.println("Is the entry {Three=3} removed? " + result);
  15. System.out.println("Updated ConcurrentHashMap: " + numbers);
  16. }
  17. }
Salida
ConcurrentHashMap: {Uno = 1, Dos = 2, Tres = 3}
Valor eliminado: 2
¿Se ha eliminado la entrada {Three = 3}? Cierto
ConcurrentHashMap actualizado: {One = 1}

Operaciones concurrentes masivas

La ConcurrentHashMapclase proporciona diferentes operaciones masivas que se pueden aplicar de forma segura a mapas concurrentes.

1. Método forEach ()

El forEach()método itera sobre nuestras entradas y ejecuta la función especificada.
Incluye dos parámetros.
  • parallelismThreshold : especifica después de cuántos elementos las operaciones en un mapa se ejecutan en paralelo.
  • transformador : transformará los datos antes de que pasen a la función especificada.
Por ejemplo,
  1. import java.util.concurrent.ConcurrentHashMap;
  2. class Main {
  3. public static void main(String[] args) {
  4. ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>();
  5. numbers.put("One", 1);
  6. numbers.put("Two", 2);
  7. numbers.put("Three", 3);
  8. System.out.println("ConcurrentHashMap: " + numbers);
  9. // forEach() without transformer function
  10. numbers.forEach(4, (k, v) -> System.out.println("key: " + k + " value: " + v));
  11. // forEach() with transformer function
  12. System.out.print("Values are ");
  13. numbers.forEach(4, (k, v) -> v, (v) -> System.out.print(v + ", "));
  14. }
  15. }
Salida
ConcurrentHashMap: {Uno = 1, Dos = 2, Tres = 3}
clave: un valor: 1
clave: dos valores: 2
clave: tres valores: 3
Los valores son 1, 2, 3,
En el programa anterior, hemos usado el umbral paralelo 4 . Esto significa que si el mapa contiene 4 entradas, la operación se ejecutará en paralelo.
Variación del método forEach ()
  • forEachEntry() - ejecuta la función especificada para cada entrada
  • forEachKey() - ejecuta la función especificada para cada tecla
  • forEachValue() - ejecuta la función especificada para cada valor

2. Método search ()

El search()método busca en el mapa en función de la función especificada y devuelve la entrada coincidente.
Aquí, la función especificada determina qué entrada se debe buscar.
También incluye un parámetro opcional parallelThreshold . El umbral paralelo especifica después de cuántos elementos en el mapa se ejecuta la operación en paralelo.
Por ejemplo,
  1. import java.util.concurrent.ConcurrentHashMap;
  2. class Main {
  3. public static void main(String[] args) {
  4. ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>();
  5. numbers.put("One", 1);
  6. numbers.put("Two", 2);
  7. numbers.put("Three", 3);
  8. System.out.println("ConcurrentHashMap: " + numbers);
  9. // Using search()
  10. String key = numbers.search(4, (k, v) -> {return v == 3 ? k: null;});
  11. System.out.println("Searched value: " + key);
  12. }
  13. }
Salida
ConcurrentHashMap: {Uno = 1, Dos = 2, Tres = 3}
Valor buscado: tres
Variantes del método search ()
  • searchEntries() - la función de búsqueda se aplica a las asignaciones de clave / valor
  • searchKeys() - la función de búsqueda solo se aplica a las teclas
  • searchValues() - la función de búsqueda solo se aplica a los valores

3. método reduce ()

El reduce()método acumula (reúne) cada entrada en un mapa. Esto se puede usar cuando necesitamos todas las entradas para realizar una tarea común, como agregar todos los valores de un mapa.
Incluye dos parámetros.
  • parallelismThreshold : especifica después de cuántos elementos, las operaciones en un mapa se ejecutan en paralelo.
  • transformador : transformará los datos antes de que pasen a la función especificada.
Por ejemplo,
  1. import java.util.concurrent.ConcurrentHashMap;
  2. class Main {
  3. public static void main(String[] args) {
  4. ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>();
  5. numbers.put("One", 1);
  6. numbers.put("Two", 2);
  7. numbers.put("Three", 3);
  8. System.out.println("ConcurrentHashMap: " + numbers);
  9. // Using search()
  10. int sum = numbers.reduce(4, (k, v) -> v, (v1, v2) -> v1 + v2);
  11. System.out.println("Sum of all values: " + sum);
  12. }
  13. }
Salida
ConcurrentHashMap: {Uno = 1, Dos = 2, Tres = 3}
Suma de todos los valores: 6
En el programa anterior, observe la declaración
  1. numbers.reduce(4, (k, v) -> v, (v1, v2) -> v1+v2);
Aquí,
  • 4 es un umbral paralelo
  • (k, v) -> v es una función de transformador. Transfiere las asignaciones de clave / valor solo a valores.
  • (v1, v2) -> v1 + v2 es una función reductora. Reúne todos los valores y agrega todos los valores.
Variantes del método reduce ()
  • reduceEntries() - devuelve el resultado de reunir todas las entradas usando la función reductora especificada
  • reduceKeys() - devuelve el resultado de reunir todas las teclas usando la función reductora especificada
  • reduceValues() - devuelve el resultado de reunir todos los valores utilizando la función reductora especificada

ConcurrentHashMap vs HashMap

Estas son algunas de las diferencias entre ConcurrentHashMapHashMap ,
  • ConcurrentHashMapes una colección segura para subprocesos . Es decir, múltiples hilos pueden acceder y modificarlo al mismo tiempo.
  • ConcurrentHashMapproporciona métodos para operaciones masivas como forEach()search()reduce().

¿Por qué ConcurrentHashMap?

  • La ConcurrentHashMapclase permite que múltiples hilos accedan a sus entradas simultáneamente.
  • Por defecto, el hashmap concurrente se divide en 16 segmentos . Esta es la razón por la cual 16 hilos pueden modificar simultáneamente el mapa al mismo tiempo. Sin embargo, cualquier cantidad de hilos puede acceder al mapa a la vez.
  • El putIfAbsent()método no anulará la entrada en el mapa si la clave especificada ya existe.
  • Proporciona su propia sincronización.

Publicar un comentario

0 Comentarios