Toujours à propos de la synchronisation

Encore une petite question. Voici un exemple de classe:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

public class A { private Collection<XListener> listeners; public A() { listeners = Collections.synchronizedCollection(new ArrayList<XListener>()); } public void addXListener(XListener listener) { listeners.add(listener); } private void fireX() { for(XListener listener : listeners) listener.x(); } }

---

Est-ce que le Collections.synchronizedCollection() garantit que le parcours via l'itérateur (foreach) par un Thread A ne pourra pas se faire "en même temps" que le listener.add() par un Thread B?
Ou alors ça garantit juste que la création de l'itérateur sera synchronisé, mais pas son parcours?

synchronizedCollection garantie que les accès avec les méthodes la classe Collection se font de maniere synchronisée.
Par exemple la méthode Collection.add devient:

Code:

---

1 2 3 4

public boolean add(E o) { synchronized(mutex) {return c.add(o);} }

---

Elle ne garantie l'accès synchronisé lors parcours de la collection avec l'iterator:

Citation:

---

Envoyé par Javadoc

It is imperative that the user manually synchronize on the returned list when iterating over it:

Code:

---

1 2 3 4 5 6 7 8

List list = Collections.synchronizedList(new ArrayList()); ... synchronized(list) { Iterator i = list.iterator(); // Must be in synchronized block while (i.hasNext()) foo(i.next()); }

---

---

OK merci, c'est ce que je pensais...

Citation:

---

Envoyé par gronono

Elle ne garantie l'accès synchronisé lors parcours de la collection avec l'iterator

---

Et sans passer par l'itérateur ? Par exemple, la méthode get(int index) est-elle synchronisée dans ce cas ?

A quoi font appel les boucles étendues (foreach) ? A l'iterator ? autre ?

Citation:

---

Envoyé par marchand_de_sable

Et sans passer par l'itérateur ? Par exemple, la méthode get(int index) est-elle synchronisée dans ce cas ?

A quoi font appel les boucles étendues (foreach) ? A l'iterator ? autre ?

---

La méthode get(int index) est synchronisée, mais forcément, la synchronisation ne met un verrou que pour l'accès à un index. Dès que tu passes à l'index suivant, le verrou est entre temps libéré et un autre est remis.

La boucle foreach fait appel à l'itérateur.

Code:

---

1 2 3 4

Collection<String> strings = new ArrayList<String>(); for(String s : strings) { ... }

---

est équivalent à

Code:

---

1 2 3 4 5 6

Collection<String> strings = new ArrayList<String>(); Iterator<String> iterator = strings.iterator(); while(iterator.hasNext()) { String s = iterator.next(); ... }

---

OK, donc ça ne servirait à rien d'utiliser "l'ancienne" boucle for avec des get(int index)... Il faudrait elle aussi la mettre dans un block synchronisé.

Merci pour l'info ;)