Existe-t-il une liste simultanée dans le JDK de Java?

Comment puis-je créer une instance de liste simultanée, où je peux accéder aux éléments par index? Le JDK a-t-il des classes ou des méthodes d'usine que je peux utiliser?

Il existe une implémentation de liste simultanée dans java.util.concurrent . CopyOnWriteArrayList en particulier.

Si vous ne vous souciez pas d'avoir un accès basé sur un index et que vous voulez simplement les caractéristiques préservant l'ordre d'insertion d'une liste, vous pouvez envisager un java.util.concurrent.ConcurrentLinkedQueue . Puisqu'il implémente Iterable, une fois que vous avez terminé d'ajouter tous les éléments, vous pouvez parcourir le contenu en utilisant la syntaxe améliorée pour:

Queue<String> globalQueue = new ConcurrentLinkedQueue<String>();

//Multiple threads can safely call globalQueue.add()...

for (String href : globalQueue) {
    //do something with href
}

Vous pouvez très bien utiliser Collections.synchronizedList (List) si tout ce dont vous avez besoin est une simple synchronisation d'invocation:

 List<Object> objList = Collections.synchronizedList(new ArrayList<Object>());

Parce que l'acte d'acquérir la position et d'obtenir l'élément à partir de la position donnée nécessite naturellement un certain verrouillage (vous ne pouvez pas avoir la liste de changements structurels entre ces deux opérations).

L'idée même d'une collection simultanée est que chaque opération en elle-même est atomique et peut être effectuée sans verrouillage / synchronisation explicite.

Par conséquent, obtenir l'élément en position à npartir d'une donnée en Listtant qu'opération atomique n'a pas trop de sens dans une situation où un accès simultané est prévu.

Vous avez ces options:

• Collections.synchronizedList(): vous pouvez encapsuler n'importe quelle Listimplémentation ( ArrayList, LinkedListou une liste tierce). L'accès à chaque méthode (lecture et écriture) sera protégé à l'aide de synchronized. Lorsque vous utilisez iterator()ou améliorez la boucle, vous devez synchroniser manuellement; lors de l'itération, les autres threads sont complètement bloqués, même en lecture. Vous pouvez également synchroniser séparément pour chacun hasNextet les nextappels, mais ConcurrentModificationExceptionc'est possible.

• CopyOnWriteArrayList: c'est cher à modifier, mais sans attendre pour lire. Les itérateurs ne jettent jamais ConcurrentModificationException, ils retournent un instantané de la liste au moment de la création de l'itérateur, même si la liste est modifiée par un autre thread pendant l'itération. Utile pour les listes rarement mises à jour. Les opérations en bloc comme addAllsont préférées pour les mises à jour - la matrice interne est copiée moins de fois.

• Vector: très similaire synchronizedList, mais l'itération est également synchronisée. Cependant, les itérateurs peuvent lancer ConcurrentModificationException, si le vecteur est modifié par un autre thread pendant l'itération.

Autres options:

• Collections.unmodifiableList(): sans verrouillage, thread-safe, mais non modifiable
• Queueou Dequepeut être une alternative si vous ajoutez / supprimez uniquement à la fin de la liste et parcourez la liste. Il n'y a pas d'accès par index et pas d'ajout / suppression à des endroits arbitraires. Ils ont plusieurs implémentations simultanées avec de meilleures performances et un meilleur accès simultané, mais cela dépasse le cadre de cette question. Vous pouvez également jeter un œil à JCTools , ils contiennent des implémentations de files d'attente plus performantes spécialisées pour un seul consommateur ou un seul producteur.

CopyOnWriteArrayList est une variante thread-safe d'ArrayList dans laquelle toutes les opérations de mutation (ajout, définition, etc.) sont implémentées en effectuant une nouvelle copie du tableau sous-jacent.

CopyOnWriteArrayList est une alternative simultanée de List synchronise les implémentations de l'interface List et de sa partie du paquet java.util.concurrent et de sa collection thread-safe.

public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable

CopyOnWriteArrayList est à sécurité intégrée et ne lève pas ConcurrentModificationException lorsque CopyOnWriteArrayList sous-jacent est modifié pendant l'itération, utilisez une copie distincte d'ArrayList.

Ceci est généralement trop coûteux car le tableau de copie impliquait chaque opération de mise à jour, une copie clonée sera créée. CopyOnWriteArrayList est le meilleur choix uniquement pour les opérations de lecture fréquentes.

/**
         * Returns a shallow copy of this list.  (The elements themselves
         * are not copied.)
         *
         * @return a clone of this list
         */
        public Object clone() {
            try {
                @SuppressWarnings("unchecked")
                CopyOnWriteArrayList<E> clone =
                    (CopyOnWriteArrayList<E>) super.clone();
                clone.resetLock();
                return clone;
            } catch (CloneNotSupportedException e) {
                // this shouldn't happen, since we are Cloneable
                throw new InternalError();
            }
        }

• http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/CopyOnWriteArrayList.html

• https://docs.oracle.com/javase/9/docs/api/java/util/concurrent/CopyOnWriteArrayList.html

• https://www.logicbig.com/tutorials/core-java-tutorial/java-collections/concurrent-collection-cheatsheet.html