Comment déboguer ConcurrentModificationException?

Il peut n'avoir rien à faire avec le bloc de synchronisation. ConcurrentModificationExceptions souvent se produire lorsque vous modifiez une collection tout en vous une itération sur les éléments.

List<String> messages = ...;
for (String message : messages) {
    //Prone to ConcurrentModificationException
    messages.add("A COMPLETELY NEW MESSAGE");
}

OriginalL'auteur Adam Paynter

Parfois, votre demande peut être complexe, trop complexe et certaines fonctions peuvent avoir trop d'effets secondaires. Aussi, peut-être un autre thread est vraiment en train de faire quelque chose de mal avec cette liste et vous ne pouvez pas trouver où facilement.

Pour mon problème, j'ai écris mon propre système de liste aux délégués une autre liste et, une fois verrouillé, toutes les autres modifications jette ConcurrentModificationException, de sorte que la mauvaise modification d'instruction à la sortie avec l'exception. Il peut également détecter les erreurs décrites ci-dessus.

importer java.util.*; 

/** 
* Créé par IntelliJ IDEA. 
* Utilisateur: francoiscassistat 
* Date: 12 juin 2010 
* Heure: 18:20:18 
* 
* 
* Verrouillable liste, faite pour déboguer ConcurrentModificationException sur les Listes. 
* Le verrouillage peut être activé ou désactivé avec setLocked(boolean). 
* Lorsque le clavier est verrouillé, tous les accès en écriture à la liste ou les itérateurs obtient ConcurrentModificationException. 
* Simple d'utilisation : 
* 
* la liste.setLocked(true); 
* 
* for (Object o : liste.iterator()) //maintenant, ce n'obtiendrez pas ConcurrentModificationException, l'autre instruction de la cause, ce sera jeté l'exception 
* { ... } 
* 
* la liste.setLocked(false); 
*/
public class LockableList<E> met en œuvre une Liste<E> { 
classe protégée LockableListIterator implements Iterator<E> { 
protégé Iterator<E> iterator; 

public LockableListIterator(Iterator<E> iterator) { 
c'.iterator = iterator; 
} 

public boolean hasNext() { 
de retour d'itérateur.hasNext(); 
} 

public E next() { 
de retour d'itérateur.next(); 
} 

public void supprimer() { 
checkLock(); 
itérateur.remove(); 
} 
} 

classe protégée LockableListListIterator implémente ListIterator<E> { 
protégé ListIterator<E> listIterator; 

public LockableListListIterator(ListIterator<E> listIterator) { 
c'.listIterator = listIterator; 
} 

public boolean hasNext() { 
retour listIterator.hasNext(); 
} 

public E next() { 
retour listIterator.next(); 
} 

public boolean hasPrevious() { 
retour listIterator.hasPrevious(); 
} 

public E précédente() { 
retour listIterator.previous(); 
} 

public int nextIndex() { 
retour listIterator.nextIndex(); 
} 

public int previousIndex() { 
retour listIterator.previousIndex(); 
} 

public void supprimer() { 
checkLock(); 
listIterator.remove(); 
} 

public void set(E) { 
checkLock(); 
listIterator.défini(e); 
} 

public void add(E e) { 
checkLock(); 
listIterator.add(e); 
} 
} 

classe protégée LockableListSubList implémente une Liste<E> 
{ 
protégé Liste<E> liste; 

public LockableListSubList(List<E> liste) { 
c'.liste = liste; 
} 

public int size() { 
retour la liste.size(); 
} 

public boolean estvide() { 
retour la liste.isEmpty(); 
} 

public boolean contains(Object o) { 
retour la liste.contient le(s); 
} 

public Iterator<E> iterator() { 
de retour de nouvelle LockableListIterator(la liste.iterator()); 
} 

public Object[] toArray() { 
retour la liste.toArray(); 
} 

public <T> T[] toArray(T []) { 
retour la liste.toArray (); 
} 

public boolean add(E e) { 
checkLock(); 
retour la liste.add(e); 
} 

public boolean remove(Object o) { 
checkLock(); 
retour la liste.supprimer(o); 
} 

public boolean containsAll(Collection<?> c) { 
retour la liste.containsAll(c); 
} 

public boolean addAll(Collection<? extends E > c) { 
checkLock(); 
retour la liste.addAll(c); 
} 

public boolean addAll(int index, Collection<? extends E > c) { 
checkLock(); 
retour la liste.addAll(indice c); 
} 

public boolean removeAll(Collection<?> c) { 
checkLock(); 
retour la liste.removeAll(c); 
} 

public boolean retainAll(Collection<?> c) { 
checkLock(); 
retour la liste.retainAll(c); 
} 

public void clear() { 
checkLock(); 
liste.clear(); 
} 

@Override 
public boolean equals(Object o) { 
retour la liste.est égal à(o); 
} 

@Override 
public int hashCode() { 
retour la liste.hashCode(); 
} 

public E get(int index) { 
retour la liste.get(index); 
} 

public E set(int index, E element) { 
checkLock(); 
retour la liste.set(indice, élément); 
} 

public void add(int index, E element) { 
checkLock(); 
liste.ajouter(indice, élément); 
} 

public E remove(int index) { 
checkLock(); 
retour la liste.remove(index); 
} 

public int indexOf(Object o) { 
retour la liste.indexOf(o); 
} 

public int lastIndexOf(Object o) { 
retour la liste.lastIndexOf(o); 
} 

public ListIterator<E> listIterator() { 
de retour de nouvelle LockableListListIterator(la liste.listIterator()); 
} 

public ListIterator<E> listIterator(int index) { 
de retour de nouvelle LockableListListIterator(la liste.listIterator(index)); 
} 

public List<E> sous-liste(int fromIndex, int toIndex) { 
de retour de nouvelle LockableListSubList(la liste.sous-liste(fromIndex, toIndex)); 
} 
} 

protégé Liste<E> liste; 
protected boolean verrouillé; 

public LockableList(List<E> liste) { 
c'.liste = liste; 
locked = false; 
} 

public boolean isLocked() { 
retour verrouillé; 
} 

public void setLocked(boolean verrouillé) { 
c'.locked = verrouillé; 
} 

protected void checkLock() { 
si (verrouillé) 
throw new ConcurrentModificationException("Verrouillé"); 
} 

public int size() { 
retour la liste.size(); 
} 

public boolean estvide() { 
retour la liste.isEmpty(); 
} 

public boolean contains(Object o) { 
retour la liste.contient le(s); 
} 

public Iterator<E> iterator() { 
de retour de nouvelle LockableListIterator(la liste.iterator()); 
} 

public Object[] toArray() { 
retour la liste.toArray(); 
} 

public <T> T[] toArray(T []) { 
retour la liste.toArray (); 
} 

public boolean add(E e) { 
checkLock(); 
retour la liste.add(e); 
} 

public boolean remove(Object o) { 
checkLock(); 
retour la liste.supprimer(o); 
} 

public boolean containsAll(Collection<?> c) { 
retour la liste.containsAll(c); 
} 

public boolean addAll(Collection<? extends E > c) { 
checkLock(); 
retour la liste.addAll(c); 
} 

public boolean addAll(int index, Collection<? extends E > c) { 
checkLock(); 
retour la liste.addAll(indice c); 
} 

public boolean removeAll(Collection<?> c) { 
checkLock(); 
retour la liste.removeAll(c); 
} 

public boolean retainAll(Collection<?> c) { 
checkLock(); 
retour la liste.retainAll(c); 
} 

public void clear() { 
checkLock(); 
liste.clear(); 
} 

@Override 
public boolean equals(Object o) { 
retour la liste.est égal à(o); 
} 

@Override 
public int hashCode() { 
retour la liste.hashCode(); 
} 

public E get(int index) { 
retour la liste.get(index); 
} 

public E set(int index, E element) { 
checkLock(); 
retour la liste.set(indice, élément); 
} 

public void add(int index, E element) { 
checkLock(); 
liste.ajouter(indice, élément); 
} 

public E remove(int index) { 
checkLock(); 
retour la liste.remove(index); 
} 

public int indexOf(Object o) { 
retour la liste.indexOf(o); 
} 

public int lastIndexOf(Object o) { 
retour la liste.lastIndexOf(o); 
} 

public ListIterator<E> listIterator() { 
de retour de nouvelle LockableListListIterator(la liste.listIterator()); 
} 

public ListIterator<E> listIterator(int index) { 
de retour de nouvelle LockableListListIterator(la liste.listIterator(index)); 
} 

public List<E> sous-liste(int fromIndex, int toIndex) { 
de retour de nouvelle LockableListSubList(la liste.sous-liste(fromIndex, toIndex)); 
} 
} 

Il suffit de l'utiliser comme ceci :

Liste liste = new LockableList(new ArrayList(...)); 
liste.setLocked(true); 

pour E e : liste.iterator()) 
{ ... } 

liste.setLocked(false); 

Espère que ça peut aider quelqu'un d'autre.

OriginalL'auteur Béatrice Cassistat

Ayant eu à traiter avec des problèmes similaires, j'ai écrit une petite aide pour déboguer l'accès simultané de situations, de certains objets (parfois à l'aide d'un débogueur modifie le comportement d'exécution tant que le problème ne se produit pas). L'approche est similaire à celle de François l'a montré, mais un peu plus générique. Peut-être que ça aide quelqu'un: http://code.google.com/p/kongcurrent/

OriginalL'auteur JanDasWiesel