Java ConcurrentHashMap

Neste tutorial, aprenderemos sobre a classe Java ConcurrentHashMap e suas operações com a ajuda de exemplos.

A ConcurrentHashMapclasse da estrutura de coleções Java fornece um mapa thread-safe. Ou seja, vários threads podem acessar o mapa de uma vez, sem afetar a consistência das entradas em um mapa.

Ele implementa a interface ConcurrentMap.

Crie um ConcurrentHashMap

Para criar um hashmap simultâneo, devemos importar o java.util.concurrent.ConcurrentHashMappacote primeiro. Depois de importar o pacote, aqui está como podemos criar hashmaps simultâneos em Java.

 // ConcurrentHashMap with capacity 8 and load factor 0.6 ConcurrentHashMap numbers = new ConcurrentHashMap(8, 0.6f);

No código acima, criamos um hashmap simultâneo denominado números.

Aqui,

  • Chave - um identificador único usado para associar cada elemento (valor) em um mapa
  • Valor - elementos associados por chaves em um mapa

Observe a peça new ConcurrentHashMap(8, 0.6). Aqui, o primeiro parâmetro é a capacidade e o segundo parâmetro é loadFactor .

  • capacidade - A capacidade deste mapa é 8. Ou seja, ele pode armazenar 8 entradas.
  • loadFactor - O fator de carga deste mapa é 0,6. Isso significa que, sempre que nossa tabela hash é preenchida em 60%, as entradas são movidas para uma nova tabela hash com o dobro do tamanho da tabela hash original.

Capacidade padrão e fator de carga

É possível criar um hashmap simultâneo sem definir sua capacidade e fator de carga. Por exemplo,

 // ConcurrentHashMap with default capacity and load factor ConcurrentHashMap numbers1 = new ConcurrentHashMap();

Por padrão,

  • a capacidade do mapa será de 16
  • o fator de carga será 0,75

Criação de ConcurrentHashMap de outros mapas

Aqui está como podemos criar um hashmap simultâneo contendo todos os elementos de outros mapas.

 import java.util.concurrent.ConcurrentHashMap; import java.util.HashMap; class Main ( public static void main(String() args) ( // Creating a hashmap of even numbers HashMap evenNumbers = new HashMap(); evenNumbers.put("Two", 2); evenNumbers.put("Four", 4); System.out.println("HashMap: " + evenNumbers); // Creating a concurrent hashmap from other map ConcurrentHashMap numbers = new ConcurrentHashMap(evenNumbers); numbers.put("Three", 3); System.out.println("ConcurrentHashMap: " + numbers); ) )

Resultado

 HashMap: (Quatro = 4, Dois = 2) ConcurrentHashMap: (Quatro = 4, Dois = 2, Três = 3)

Métodos de ConcurrentHashMap

A ConcurrentHashMapclasse fornece métodos que nos permitem realizar várias operações no mapa.

Inserir elementos no ConcurrentHashMap

  • put() - insere o mapeamento de chave / valor especificado no mapa
  • putAll() - insere todas as entradas do mapa especificado neste mapa
  • putIfAbsent() - insere o mapeamento de chave / valor especificado no mapa se a chave especificada não estiver presente no mapa

Por exemplo,

 import java.util.concurrent.ConcurrentHashMap; class Main ( public static void main(String() args) ( // Creating ConcurrentHashMap of even numbers ConcurrentHashMap evenNumbers = new ConcurrentHashMap(); // Using put() evenNumbers.put("Two", 2); evenNumbers.put("Four", 4); // Using putIfAbsent() evenNumbers.putIfAbsent("Six", 6); System.out.println("ConcurrentHashMap of even numbers: " + evenNumbers); //Creating ConcurrentHashMap of numbers ConcurrentHashMap numbers = new ConcurrentHashMap(); numbers.put("One", 1); // Using putAll() numbers.putAll(evenNumbers); System.out.println("ConcurrentHashMap of numbers: " + numbers); ) )

Resultado

 ConcurrentHashMap de números pares: (Six = 6, Four = 4, Two = 2) ConcurrentHashMap de números: (Six = 6, One = 1, Four = -4, Two = 2)

Acessar elementos ConcurrentHashMap

1. Usando entrySet (), keySet () e values ​​()

  • entrySet() - retorna um conjunto de todos os mapeamentos de chave / valor do mapa
  • keySet() - retorna um conjunto de todas as chaves do mapa
  • values() - retorna um conjunto de todos os valores do mapa

Por exemplo,

 import java.util.concurrent.ConcurrentHashMap; class Main ( public static void main(String() args) ( ConcurrentHashMap numbers = new ConcurrentHashMap(); numbers.put("One", 1); numbers.put("Two", 2); numbers.put("Three", 3); System.out.println("ConcurrentHashMap: " + numbers); // Using entrySet() System.out.println("Key/Value mappings: " + numbers.entrySet()); // Using keySet() System.out.println("Keys: " + numbers.keySet()); // Using values() System.out.println("Values: " + numbers.values()); ) )

Resultado

 ConcurrentHashMap: (Um = 1, Dois = 2, Três = 3) Mapeamentos de chave / valor: (Um = 1, Dois = 2, Três = 3) Chaves: (Um, Dois, Três) Valores: (1, 2, 3 )

2. Usando get () e getOrDefault ()

  • get()- Retorna o valor associado à chave especificada. Retorna nullse a chave não for encontrada.
  • getOrDefault()- Retorna o valor associado à chave especificada. Retorna o valor padrão especificado se a chave não for encontrada.

Por exemplo,

 import java.util.concurrent.ConcurrentHashMap; class Main ( public static void main(String() args) ( ConcurrentHashMap numbers = new ConcurrentHashMap(); numbers.put("One", 1); numbers.put("Two", 2); numbers.put("Three", 3); System.out.println("ConcurrentHashMap: " + numbers); // Using get() int value1 = numbers.get("Three"); System.out.println("Using get(): " + value1); // Using getOrDefault() int value2 = numbers.getOrDefault("Five", 5); System.out.println("Using getOrDefault(): " + value2); ) )

Resultado

 ConcurrentHashMap: (One = 1, Two = 2, Three = 3) Usando get (): 3 Usando getOrDefault (): 5

Remover elementos ConcurrentHashMap

  • remove(key) - retorna e remove a entrada associada à chave especificada do mapa
  • remove(key, value) - removes the entry from the map only if the specified key mapped to the specified value and return a boolean value

For example,

 import java.util.concurrent.ConcurrentHashMap; class Main ( public static void main(String() args) ( ConcurrentHashMap numbers = new ConcurrentHashMap(); numbers.put("One", 1); numbers.put("Two", 2); numbers.put("Three", 3); System.out.println("ConcurrentHashMap: " + numbers); // remove method with single parameter int value = numbers.remove("Two"); System.out.println("Removed value: " + value); // remove method with two parameters boolean result = numbers.remove("Three", 3); System.out.println("Is the entry (Three=3) removed? " + result); System.out.println("Updated ConcurrentHashMap: " + numbers); ) )

Output

 ConcurrentHashMap: (One=1, Two=2, Three=3) Removed value: 2 Is the entry (Three=3) removed? True Updated ConcurrentHashMap: (One=1)

Bulk ConcurrentHashMap Operations

The ConcurrentHashMap class provides different bulk operations that can be applied safely to concurrent maps.

1. forEach() Method

The forEach() method iterates over our entries and executes the specified function.

It includes two parameters.

  • parallelismThreshold - It specifies that after how many elements operations in a map are executed in parallel.
  • transformer - This will transform the data before the data is passed to the specified function.

For example,

 import java.util.concurrent.ConcurrentHashMap; class Main ( public static void main(String() args) ( ConcurrentHashMap numbers = new ConcurrentHashMap(); numbers.put("One", 1); numbers.put("Two", 2); numbers.put("Three", 3); System.out.println("ConcurrentHashMap: " + numbers); // forEach() without transformer function numbers.forEach(4, (k, v) -> System.out.println("key: " + k + " value: " + v)); // forEach() with transformer function System.out.print("Values are "); numbers.forEach(4, (k, v) -> v, (v) -> System.out.print(v + ", ")); ) )

Output

 ConcurrentHashMap: (One = 1, Two = 2, Three = 3) key: One value: 1 key: Two value: 2 key: Three value: 3 Values are 1, 2, 3,

In the above program, we have used parallel threshold 4. This means if the map contains 4 entries, the operation will be executed in parallel.

Variation of forEach() Method

  • forEachEntry() - executes the specified function for each entry
  • forEachKey() - executes the specified function for each key
  • forEachValue() - executes the specified function for each value

2. search() Method

The search() method searches the map based on the specified function and returns the matched entry.

Here, the specified function determines what entry is to be searched.

It also includes an optional parameter parallelThreshold. The parallel threshold specifies that after how many elements in the map the operation is executed in parallel.

For example,

 import java.util.concurrent.ConcurrentHashMap; class Main ( public static void main(String() args) ( ConcurrentHashMap numbers = new ConcurrentHashMap(); numbers.put("One", 1); numbers.put("Two", 2); numbers.put("Three", 3); System.out.println("ConcurrentHashMap: " + numbers); // Using search() String key = numbers.search(4, (k, v) -> (return v == 3 ? k: null;)); System.out.println("Searched value: " + key); ) )

Output

 ConcurrentHashMap: (One=1, Two=2, Three=3) Searched value: Three

Variants of search() Method

  • searchEntries() - search function is applied to key/value mappings
  • searchKeys() - search function is only applied to the keys
  • searchValues() - search function is only applied to the values

3. reduce() Method

The reduce() method accumulates (gather together) each entry in a map. This can be used when we need all the entries to perform a common task, like adding all the values of a map.

It includes two parameters.

  • parallelismThreshold - It specifies that after how many elements, operations in a map are executed in parallel.
  • transformer - This will transform the data before the data is passed to the specified function.

For example,

 import java.util.concurrent.ConcurrentHashMap; class Main ( public static void main(String() args) ( ConcurrentHashMap numbers = new ConcurrentHashMap(); numbers.put("One", 1); numbers.put("Two", 2); numbers.put("Three", 3); System.out.println("ConcurrentHashMap: " + numbers); // Using search() int sum = numbers.reduce(4, (k, v) -> v, (v1, v2) -> v1 + v2); System.out.println("Sum of all values: " + sum); ) )

Output

 ConcurrentHashMap: (One=1, Two=2, Three=3) Sum of all values: 6

In the above program, notice the statement

 numbers.reduce(4, (k, v) -> v, (v1, v2) -> v1+v2);

Here,

  • 4 is a parallel threshold
  • (k, v) -> v is a transformer function. It transfers the key/value mappings into values only.
  • (v1, v2) -> v1+v2 is a reducer function. It gathers together all the values and adds all values.

Variants of reduce() Method

  • reduceEntries() - returns the result of gathering all the entries using the specified reducer function
  • reduceKeys() - returns the result of gathering all the keys using the specified reducer function
  • reduceValues() - returns the result of gathering all the values using the specified reducer function

ConcurrentHashMap vs HashMap

Here are some of the differences between ConcurrentHashMap and HashMap,

  • ConcurrentHashMap is a thread-safe collection. That is, multiple threads can access and modify it at the same time.
  • ConcurrentHashMap provides methods for bulk operations like forEach(), search() and reduce().

Why ConcurrentHashMap?

  • A ConcurrentHashMapclasse permite que vários threads acessem suas entradas simultaneamente.
  • Por padrão, o hashmap simultâneo é dividido em 16 segmentos . Esta é a razão pela qual 16 threads têm permissão para modificar o mapa ao mesmo tempo. No entanto, qualquer número de threads pode acessar o mapa por vez.
  • O putIfAbsent()método não substituirá a entrada no mapa se a chave especificada já existir.
  • Ele fornece sua própria sincronização.

Artigos interessantes...