Guava MultiMap y ConcurrentModificationException

Question

No entiendo por qué obtengo una ConcurrentModificationException cuando repito este multimap. Leí el siguiente entry, pero no estoy seguro de haber entendido todo. Traté de agregar un bloque sincronizado. Pero mi duda es con qué sincronizar y cuándo.

El multimap es un campo y ha creado así:

private Multimap<GenericEvent, Command> eventMultiMap = 
    Multimaps.synchronizedMultimap(HashMultimap.<GenericEvent, Command> create()); 

y se utiliza de esta manera:

eventMultiMap.put(event, command); 

y como esto (he intentado sincronizar esta parte del mapa, pero sin éxito)

for (Entry<GenericEvent, Command> entry : eventMultiMap.entries()) { 
    if (entry.getValue().equals(command)) { 
     eventMultiMap.remove(entry.getKey(), entry.getValue()); 
     nbRemoved++; 
    } 
} 

Answer 1

En java8 también se puede utilizar un enfoque lambda:

eventMultiMap.entries().removeIf(genericEventCommandEntry -> genericEventCommandEntry.getValue().equals(command));

Answer 2

Llamar eliminar en una colección mientras está iterando a través de ella causar una ConcurrentModificationException cada vez, incluso si todo está hecho en el mismo subproceso: lo correcto es obtener un iterador explícito y llamar a .remove() sobre eso.

Editar: La modificación de su ejemplo:

Iterator<Map.Entry<GenericEvent, Command>> i = eventMultiMap.entries().iterator(); 
while (i.hasNext()) { 
    if (i.next().getValue().equals(command)) { 
     i.remove(); 
     nbRemoved++; 
    } 
} 

Answer 3

Si otro hilo podría modificar multimap mientras que esta lógica se está ejecutando, tendrá que añadir un bloque sincronizado con el código de MHarris:

synchronized (eventMultimap) { 
    Iterator<Entry<GenericEvent, Command>> i = eventMultiMap.entries.iterator(); 
    while (i.hasNext()) { 
    if (i.next().getValue().equals(command)) { 
     i.remove(); 
     nbRemoved++; 
    } 
    } 
} 

o bien, puede omitir el iterador de la siguiente manera,

synchronized (eventMultimap) { 
    int oldSize = eventMultimap.size(); 
    eventMultimap.values().removeAll(Collections.singleton(command)); 
    nbRemoved = oldSize - eventMultimap.size(); 
} 

el removeAll() llamada no hace requiere sincronización Sin embargo, si omite el bloque sincronizado, el multimap podría mutar entre la llamada removeAll() y una de las llamadas al tamaño(), lo que llevaría a un valor incorrecto de nbRemoved.

Ahora, si su código es de subproceso único y solo desea evitar una llamada a ConcurrentModificationException, puede omitir la lógica Multimaps.synchronizedMultimap y synchronized (eventMultimap).

Answer 4

Es posible que desee ver this blogpost para otra trampa produciendo un ConcurrentModificationException al atravesar un multimapa, sin que interfiera ningún otro hilo. En resumen, si recorre las teclas de multimap, accede a la colección respectiva de valores asociados con cada clave y elimina algún elemento de dicha colección, si ese elemento es el último de la colección, va a tener ConcurrentModificationException cuando intente para acceder a la siguiente clave, porque vaciar una colección desencadena la eliminación de la clave, lo que modifica estructuralmente el conjunto de claves del multimap.

Answer 5

Prefiero Multimap.values().iterator() si no te importa la llave. También debe intentar evitar el uso de bloques sincronizados tanto como sea posible, ya que no puede priorizar las lecturas/escrituras con eficacia.

ReadWriteLock lock = new ReentrantReadWriteLock(); 
Lock writeLock = lock.writeLock(); 

public void removeCommands(Command value) { 
    try { 
    writeLock.lock(); 
    for (Iterator<Command> it = multiMap.values().iterator(); it.hasNext();) { 
     if (it.next() == value) { 
     it.remove(); 
     } 
    } 
    } finally { 
    writeLock.unlock(); 
    } 
}