En utilisant synchronizedList avec boucle et ajouter des éléments à l'intérieur il

Question

J'utilise

Collections.synchronizedList(new ArrayList<T>()) 

partie du code est:

list = Collections.synchronizedList(new ArrayList<T>()); 

public void add(T arg) { 
    int i; 
    synchronized (list) { 
     for (i = 0; i < list.size(); i++) { 
      T arg2 = list.get(i); 

      if (arg2.compareTo(arg) < 0) { 
       list.add(i, arg); 
       break; 
      } 

     } 

Est-il vrai que pour la boucle est réellement en utilisant iterator et donc doit envelopper le pour avec synchronisé?

Est-il thread-sûr à utiliser synchronisé et ajouter à l'intérieur comme je l'ai fait ici? Je suis désolé si ces questions sont très basiques, je suis nouveau sur le sujet et je n'ai pas trouvé de réponses sur internet. Merci!

Answer 1

Est-il vrai que pour la boucle utilise réellement l'itérateur et donc je dois envelopper avec pour synchronisé?

Votre question comporte deux parties. Tout d'abord, non, vous n'utilisez pas d'itérateur ici, c'est une base pour la boucle.

La version améliorée pour la boucle est la boucle qui utilise un itérateur:

for (T element : list) { ... } 

Vous pouvez voir in the language spec comment cela utilise le iterator - chercher où il est dit « L'amélioration de la déclaration est équivalente à une base pour déclaration du formulaire ". Deuxièmement, même si vous n'utilisez pas d'itérateur, vous avez besoin synchronized. Les deux sont orthogonaux.

Vous effectuez plusieurs opérations (size, get et add), avec des dépendances entre eux. Vous devez vous assurer qu'aucun autre thread interfère avec votre logique:

• le get dépend du size, puisque vous ne voulez pas essayer d'obtenir un élément avec index >= size, par exemple;
• le add dépend du get, puisque vous essayez apparemment de vous assurer que les éléments de la liste sont triés. Si un autre thread peut se faufiler et changer l'élément après vous, vous pouvez insérer le nouvel élément au mauvais endroit.

Vous évitez correctement cette interférence possible grâce à la synchronisation sur cette list, et la création du synchronizedList de telle sorte que rien d'autre que le synchronizedList peut obtenir un accès direct à la liste sous-jacente.

Answer 2

Si votre argument arg2.compareTo (arg) ne renvoie jamais 0 (zéro), vous pouvez utiliser TreeSet.Sera beaucoup plus simple:

set = Collections.synchronizedSet(new TreeSet<T>()); 

public void add(T arg) { 
    set.add(arg); 
} 

Si vous avez besoin maintenir mêmes éléments (compareTo retourne 0) puis utilisez la liste:

list = new ArrayList<T>(); 

public void add(T arg) { 
    synchronized (list) { 
     int index = Collections.binarySearch(list, arg); 
     list.add(index, arg); 
    } 
} 

première et deuxième complexité des cas seront log (N) (10 pour 1000 articles). La complexité de votre code est N (1000 pour 1000 éléments).