[synchronized] ConcurrentModificationException sur une itération

Version imprimable

Bonjour,

j'ai écrit un bout de code qui démarre deux threads, l'un ajoute des données à une liste et l'autre en retire.
L'utilisation d'un Iterator pour retrouver l'objet à supprimer provoquent rapidement une ConcurrentModificationException.

Avez-vous une solution à me proposer.

ex :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
public class Tmp {
 
	private List datas = new Vector();
 
	public static void main(String[] args) {
		Tmp t = new Tmp();
		t.new ThreadAdd().start();
		t.new ThreadRemove().start();
	}
 
	private class ThreadAdd extends Thread {
		public void run() {
			while (true) {
				System.out.println(datas);
				datas.add(new Object());
 
				attendre(20);
			}
		}
	}
 
	private class ThreadRemove extends Thread {
		public void run() {
			while (true) {
				attendre(30);
 
				System.err.println(datas);
				//synchronized (datas) { => inefficace 
					Iterator it = datas.iterator();
					while (it.hasNext()) {
						Object o = it.next();
						datas.remove(0);
					}
				//}
			}
		}
	}
 
	private static void attendre(long l) {
		try {
			Thread.sleep(l);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

et en quelques millièmes de seconde j'obtiens :

Code:

1
2
3
4
5
 
java.util.ConcurrentModificationException
	at java.util.AbstractList$Itr.checkForComodification(AbstractList.java:448)
	at java.util.AbstractList$Itr.next(AbstractList.java:419)
	at test.Tmp$ThreadRemove.run(Tmp.java:41)

11/01/2007, 12h27
iohack
List list = Collections.synchronizedList(new ArrayList(...));
( extrait de la javadoc ) ;)
il ne faut plus utiliser de Vector.
Sinon tu peux toujours synchroniser ton iterator :
Code:

1 2 3 4 synchrnonized(this.datas){ Iterator ... }
11/01/2007, 12h37
adiGuba
Salut,

En réalité le synchronized sur ta collection n'est pas inefficace, mais il y a deux problèmes dans ton code qui peuvent provoquer des ConcurrentModificationException.

Cette exception survient pendant le parcours d'une collection via un itérateur alors que la collection est modifié entre temps, que ce soit par un autre thread ou par le même thread...
1. Tu dois donc utiliser une synchronisation pour éviter que le thread d'ajout ne modifie la collection pendant le parcours. Cela bien entendu car Vector est thread-safe. Si tu aurais utilisé une autre type de collection non thread-safe il faudrait utiliser les méthodes Collections.synchronizedXXX() (note au passage que c'est souvent recommandé d'utiliser cela plutôt que Vector).
2. Mais si tu as quand même une exception, c'est que tu peux avoir une ConcurrentModificationException au sein du même thread : lors du parcourt d'une collection via un itérateur, on ne doit pas modifier la collection pendant ce parcours, à moins d'utiliser les méthodes de l'itérateur en question. Il faut donc que tu utilises la méthode remove() de l'itérateur et non pas de ta liste...
Au final, ton itération doit ressembler à cela :
Code:

1 2 3 4 5 6 7 synchronized (datas) { Iterator it = datas.iterator(); while (it.hasNext()) { Object o = it.next(); it.remove(); } }
Enfin quelques remarques en passant :
- Comme je l'ai dit, Vector n'est plus vraiment d'actualité. Tu pourrais surement utilisé d'autre classe peut-être plus adapté. Et c'est d'autant plus vrai sous Java 5.0 et son API de concurrence qui propose un bon paquet de collection thread-safe et performante...
- Si tu veux simplement supprimé tous les éléments tu peux directement utilisé la méthode clear() (je dis ca au cas où, même si je pense que par la suite ton itération effectuera des traitements sur les objets supprimé)
a++
11/01/2007, 13h56
_Eric_

Merci pour ces réponses rapides, ça semble fonctionner.