Interface Java ConcurrentMap

Neste tutorial, vamos aprender sobre a interface Java ConcurrentMap e seus métodos.

A interface ConcurrentMap do Java Collection Framework oferece mapeamentos thread-safe. Isso significa que várias threads podem acessar essa representação ao mesmo tempo, sem afetar a consistência dos itens no mapeamento.

ConcurrentMap é chamado de map sincronizado.

Ela herdaInterface Map。

Classe que implementa o ConcurrentMap

Como o ConcurrentMap é uma interface, não é possível criar objetos a partir dela.

Para usar as funcionalidades da interface ConcurrentMap, precisamos usar a classe ConcurrentHashMap que implementa essa interface.

Como usar ConcurrentMap?}

Para usar ConcurrentMap,我们必须首先 importar o pacote java.util.concurrent.ConcurrentMap. Após a importação do pacote, o mapeamento concorrente será criado conforme as seguintes métodos.

//　Uso da classe ConcurrentHashMap
ConcurrentMap<Key, Value> numbers = new ConcurrentHashMap<>();

No código acima, criamos um ConcurrentMap chamado numbers.

Aqui,

• Key - Usado para identificar de forma única cada elemento (valor) do mapa

• Value - Elemento associado ao chave no mapa

Métodos de ConcurrentMap

A interface ConcurrentMap contém todos os métodos da interface Map. Isso porque Map é o superinterface da interface ConcurrentMap.

Além desses métodos, aqui estão os métodos específicos da interface ConcurrentMap.

• putIfAbsent() - Se a chave especificada ainda não estiver associada a nenhum valor, associar a chave especificada/O valor é inserido no mapeamento.

• compute() - Calcular a entrada (chave/Mapeamento de valores).

• computeIfAbsent() - Se a chave ainda não estiver mapeada para nenhum valor, calcular um valor usando a função especificada para a chave.

• computeIfPresent() - Se o valor especificado já estiver mapeado para a chave, calcular uma nova entrada (chave/Mapeamento de valores).

• forEach() - Acessar todos os itens do mapa e executar a operação especificada.

• merge() -Se a chave já estiver mapeada para algum valor, então combine o novo valor com o valor antigo da chave. Se a chave ainda não estiver mapeada, este método associará o valor especificado à chave.

Implementação de ConcurrentMap no ConcurrentHashMap

import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ConcurrentHashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Usando ConcurrentHashMap para criar ConcurrentMap
　　　　　　　　ConcurrentMap<String, Integer> numbers = new ConcurrentHashMap<>();
　　　　　　　　//　Inserir elementos no map
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("ConcurrentMap:　"　+　numbers);
　　　　　　　　//Acessar chave específica
　　　　　　　　int　value　=　numbers.get("One");
　　　　　　　　System.out.println("Valor acessado:　"　+　value);
　　　　　　　　//Remover valor especificado pela chave
　　　　　　　　int　removedValue　=　numbers.remove("Two");
　　　　　　　　System.out.println("Valor removido:　"　+　removedValue);
　　　　}
}

Resultados de Saída

ConcurrentMap:　{One=1,　Two=2,　Three=3}
Valor acessado:　1
Valor removido:　2

Para obter mais informações sobre ConcurrentHashMap, acesseJava ConcurrentHashMap。