Volatile HashMap vs ConcurrentHashMap

Question

Tengo una clase de caché que contiene un volatile HashMap<T> para almacenar elementos de caché.

Tengo curiosidad de cuáles serían las consecuencias de cambiar volatile HashMap a ConcurrentHashMap?

¿Aumentaré mi rendimiento? Este caché es de solo lectura.

¿Cuál sería la mejor opción para usar? solo HashMap? La memoria caché se está rellenando en un intervalo.

Answer 1

En primer lugar, parece que no entiende lo que hace la palabra clave volatile. Se asegura de que si el valor de referencia mantenido por la variable declarada volatile cambia, otros subprocesos lo verán en lugar de tener una copia en caché. No tiene nada que ver con la seguridad del hilo con respecto al acceso al HashMap

Dado que, y el hecho de que diga el HashMap es de solo lectura ... no necesita utilizar nada que proporcione hilo. de seguridad que incluye una edición ConcurrentHashMap

añadir: su última edición que ahora dicen "La memoria caché se está llenando en un intervalo de"

eso no es de sólo lectura entonces, ¿verdad?

Si usted va a tener roscas lee de éste mientras se está escribiendo (la actualización del HashMap existente), entonces debería usar un ConcurrentHashMap, sí.

Si está completando una nueva HashMap luego asignar a la variable existente, a continuación, utiliza volatile

Answer 2

Usted dice que el caché se, sino que también van a actualizar en un intervalo que parece contradictorio de sólo lectura.

Si todo el caché se actualiza en un intervalo, seguiría usando el volátil. El elemento volátil se asegurará de que el mapa actualizado se publique de forma segura.

public final class Cache 
{ 
    private volatile Map<?,?> cache; 

    private void mapUpdate() { 
     Map<?,?> newCache = new HashMap<>(); 

     // populate the map 

     // update the reference with an immutable collection 
     cache = Collections.unmodifiableMap(newCache); 
    } 
} 

Si el intervalo de actualización es la modificación de la misma caché, entonces es probable que desee utilizar un ConcurrentHashMap, o copiar el mapa, actualizar la copia, y actualizar la referencia.

public final class Cache 
{ 
    private volatile Map<?,?> cache; 

    private void mapUpdate() { 
     Map<?,?> newCache = new HashMap<>(cache); 

     // update the map 

     // update the reference with an immutable collection 
     cache = Collections.unmodifiableMap(newCache); 
    } 
}