Contadores de incremento automático almacenados en ConcurrentHashMap

Question

Me gustaría recopilar algunas métricas de varios lugares en una aplicación web. Para simplificar, todos estos serán contadores y, por lo tanto, la única operación modificadora es incrementarlos en 1.

Los incrementos serán simultáneos y frecuentes. Las lecturas (volcar las estadísticas) es una operación rara.

Estaba pensando en utilizar un ConcurrentHashMap. El problema es cómo incrementar los contadores correctamente. Como el mapa no tiene una operación de "incremento", primero necesito leer el valor actual, incrementarlo en lugar de poner el nuevo valor en el mapa. Sin más código, esta no es una operación atómica.

¿Es posible lograr esto sin sincronización (lo que anularía el propósito del ConcurrentHashMap)? ¿Tengo que mirar Guava?

Gracias por cualquier apuntador.

---

P.S.
Hay una pregunta relacionada sobre SO (Most efficient way to increment a Map value in Java), pero centrado en el rendimiento y no multi-threading

ACTUALIZACIÓN
Para los que llegan aquí a través de búsquedas sobre el mismo tema: además de las respuestas a continuación, hay una utilidad presentation que incidentalmente cubre el mismo tema. Ver diapositivas 24-33.

Answer 1

Estás muy cerca. ¿Por qué no intentas algo como un ConcurrentHashMap<Key, AtomicLong>? Si sus Key s (métricas) no cambian, puede usar simplemente un estándar HashMap (son seguros para la lectura si se leen solo, pero sería conveniente que lo haga explícito con ImmutableMap de Google Collections o Collections.unmodifiableMap, etc.).

De esta manera, puede usar map.get(myKey).incrementAndGet() para mostrar las estadísticas.

Answer 2

Aparte de ir con AtomicLong, puede hacer lo habitual lo cas de circuito:

private final ConcurrentMap<Key,Long> counts = 
    new ConcurrentHashMap<Key,Long>(); 

public void increment(Key key) { 
    if (counts.putIfAbsent(key, 1)) == null) { 
     return; 
    } 

    Long old; 
    do { 
     old = counts.get(key); 
    } while (!counts.replace(key, old, old+1)); // Assumes no removal. 
} 

(no he escrito una do - bucle while para las edades.)

Para valores pequeños de la Long probablemente se "almacenará en caché". Para valores más largos, puede requerir asignación. Pero las asignaciones son en realidad extremadamente rápidas (y puede almacenar en caché aún más), depende de lo que espere, en el peor de los casos.

Answer 3

El nuevo AtomicLongMap de Guava (en la versión 11) podría cubrir esta necesidad.

Answer 4

Tengo una necesidad de hacer lo mismo. Estoy usando ConcurrentHashMap + AtomicInteger. Además, se introdujo ReentrantRW Lock para descarga atómica (comportamiento muy similar).

Probado con 10 llaves y 10 hilos por cada llave. Nada se perdió Aún no he probado varios hilos de descarga, pero espero que funcione.

Massive singleusermode flush me está torturando ... Quiero eliminar RWLock y descomponer el enjuague en trozos pequeños. Mañana.

private ConcurrentHashMap<String,AtomicInteger> counters = new ConcurrentHashMap<String, AtomicInteger>(); 
private ReadWriteLock rwLock = new ReentrantReadWriteLock(); 

public void count(String invoker) { 

    rwLock.readLock().lock(); 

    try{ 
     AtomicInteger currentValue = counters.get(invoker); 
     // if entry is absent - initialize it. If other thread has added value before - we will yield and not replace existing value 
     if(currentValue == null){ 
      // value we want to init with 
      AtomicInteger newValue = new AtomicInteger(0); 
      // try to put and get old 
      AtomicInteger oldValue = counters.putIfAbsent(invoker, newValue); 
      // if old value not null - our insertion failed, lets use old value as it's in the map 
      // if old value is null - our value was inserted - lets use it 
      currentValue = oldValue != null ? oldValue : newValue; 
     } 

     // counter +1 
     currentValue.incrementAndGet(); 
    }finally { 
     rwLock.readLock().unlock(); 
    } 

} 

/** 
* @return Map with counting results 
*/ 
public Map<String, Integer> getCount() { 
    // stop all updates (readlocks) 
    rwLock.writeLock().lock(); 
    try{ 
     HashMap<String, Integer> resultMap = new HashMap<String, Integer>(); 
     // read all Integers to a new map 
     for(Map.Entry<String,AtomicInteger> entry: counters.entrySet()){ 
      resultMap.put(entry.getKey(), entry.getValue().intValue()); 
     } 
     // reset ConcurrentMap 
     counters.clear(); 
     return resultMap; 

    }finally { 
     rwLock.writeLock().unlock(); 
    } 

} 

Answer 5

En Java 8:

ConcurrentHashMap<String, LongAdder> map = new ConcurrentHashMap<>(); 

map.computeIfAbsent("key", k -> new LongAdder()).increment(); 

Answer 6

El siguiente código me funcionó sin sincronización para frecuencias palabras de contar

protected void updateFreqCountForText(Map<String, Integer> wordFreq, String line) { 
      ConcurrentMap<String, Integer> wordFreqConc = (ConcurrentMap<String, Integer>) wordFreq; 
      Pattern pattern = Pattern.compile("[a-zA-Z]+"); 
      Matcher matcher = pattern.matcher(line); 
      while (matcher.find()) { 
       String word = matcher.group().toLowerCase(); 
       Integer oldCount; 

       oldCount = wordFreqConc.get(word); 
       if (oldCount == null) { 
        oldCount = wordFreqConc.putIfAbsent(word, 1); 
        if (oldCount == null) 
         continue; 
        else wordFreqConc.put(word, oldCount + 1); 
       } 
       else 
        do { 
         oldCount = wordFreqConc.get(word); 
        } while (!wordFreqConc.replace(word, oldCount, oldCount + 1)); 

      } 
     }