ConcurrentHashMap

ConcurrentHashMap é uma melhoria do HashMap, pois sabemos que, ao lidar com Threads, o HashMap não é uma boa escolha porque o em termos de desempenho deixa muito a desejar.

A classe ConcurrentHashMap é thread-safe, ou seja, várias threads podem operar em um único objeto sem complicações. Ao mesmo tempo, qualquer número de encadeamentos é aplicável para uma operação de leitura sem bloquear o objeto ConcurrentHashMap que não existe no HashMap.

A estrutura de dados que o ConcurrentHashMap utiliza é a HashTable.

No ConcurrentHashMap, o objeto é dividido em vários segmentos de acordo com o concurrency-level, e como default o concurrency-level do ConcurrentHashMap é 16.


No ConcurrentHashMap, a qualquer momento mais que uma thread pode executar operação de recuperação de valor, só que para fazer update no objeto, a thread deve bloquear esse segmento específico que a thread deseja operar. Este tipo de mecanismo de bloqueio é conhecido como Segment locking or bucket locking. Consequentemente, 16 operações de update podem ser realizadas por threads.

A inserção de objetos nulos não é possível em ConcurrentHashMap como chave ou valor. Diferentemente da implementação mais utilizada, a HashMap.

public class ConcurrentHashMap<K,​V> extends AbstractMap<K,​V> implements ConcurrentMap<K,​V>, Serializable

Onde K é a chave do objeto e V é o valor do objeto.

Inicializando um ConcurrentHashMap

Podemos utilizar um dos 5 contrutores para isso:

//Cria um novo map vazio com valores default: initial capacity (16), load factor (0.75) e concurrencyLevel (16).
new ConcurrentHashMap<>();

//Cria um novo map vazio com: initial capacity que foi definida, e com default load factor (0.75) e concurrencyLevel (16).
new ConcurrentHashMap<>(int initialCapacity);

//Cria um novo map vazio com: initial capacity e load factor que foram definidos, e com concurrencyLevel default (16).
new ConcurrentHashMap<>(int initialCapacity, float loadFactor);

//Cria um novo map vazio com: initial capacity, load factor e concurrencyLevel que foram definidos.
new ConcurrentHashMap<>(int initialCapacity, float loadFactor, int concurrencyLevel);

//Cria um novo map com os mesmos atributos do map passado como parâmetro.
new ConcurrentHashMap<>(Map m);

Por quê?

Quando precisar de alta simultaneidade em seu projeto.

É thread-safe sem sincronizar todo o mapa. (apenas os segmentos, lembram?)

As leituras podem acontecer muito rapidamente enquanto a gravação é feita com um bloqueio.

Não há bloqueio no nível do objeto.

O bloqueio tem uma granularidade muito mais fina no nível do depósito de hashmap.

Não lança uma ConcurrentModificationException se uma thread tenta modificá-lo enquanto outra está iterando sobre ele.

ConcurrentHashMap usa uma infinidade de bloqueios.


🙂

Published by Ivan Marrêta

Software Engineer

3 thoughts on “ConcurrentHashMap

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

%d bloggers like this: