Discussion :

[®om]

Encore une petite question. Voici un exemple de classe:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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?

[gronono]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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:

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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());
  }

[®om]

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

[marchand_de_sable]

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 ?

[®om]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

est équivalent à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
Collection<String> strings = new ArrayList<String>();
Iterator<String> iterator = strings.iterator();
while(iterator.hasNext()) {
    String s = iterator.next();
    ...
}

[marchand_de_sable]

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