Est-il une Liste concurrente en Java JDK?

Comment puis-je créer une Liste concurrente exemple, où je peux accéder à des éléments à l'index? Le JDK ont toutes les classes ou à l'usine, les méthodes que je peux utiliser?

Pourquoi ne pas constructif? Plusieurs projets de CopyOnWriteArrayList qui ne se trouve pas dans .Net. Vous pouvez dire que les deux questions se rapportent les uns aux autres mais pas à fermer celui-ci!!!
Dans .NET l'équivalent de CopyOnWriteArrayList sont Immuables Collections. Une collecte simultanée est celle qui n'a pas besoin d'être bloqué à modifier (comme ConcurrentQueue etc), PAS un qui copie son contenu à chaque fois qu'il est copié.
Je n'ai aucune idée de pourquoi Jarrod Roberson pense que c'était une bonne idée de prendre l'détaillée des modifications apportées par Stephan et revenir en arrière à l'original, mal formulé la question. Jarrod la réponse est encore parfaitement acceptable. En fait, CopyOnWriteArrayList est la seule concurrente de la classe de mise en œuvre de la Liste dans le JDK. Intrigué...
Parce que l'on a accepté la réponse a été à la question et Stephan mettre complètement une question sans rapport avec un tas de code source que le origine affiche n'incluent pas de partout le changement de la question complètement, ce qui a généré plus de réponses qui ont été suggérant d'autres choses que de la List l'original spécifiquement dit est un condition, qui est considéré comme du vandalisme. Un modérateur est déjà verrouillé la question parce que les gens qui se plaignent que les réponses ne répondez pas que vandalisé version de la question.
/locked/closed/ commentaire précédent
Il n'y a aucune raison pour que cette question soit fermé. Il pose des questions sur les classes du JDK, qui n'est rien comme à la recherche d'une bibliothèque; c'est la base de Java.

InformationsquelleAutor AlikElzin-kilaka | 2011-08-02

159

Il y a une liste concurrente de la mise en œuvre dans java.util.simultanées. CopyOnWriteArrayList en particulier.
- Remarque la copie de l'ensemble de la liste à chaque insertion, de sorte qu'il est souvent inefficace.
- Mais elle ne peut plus s' plus efficace si vous êtes itération beaucoup plus que vous effectuez une mise à jour.
- Ne fonctionne pas bien comme montré ici. J'ai des exceptions, même si je viens d'utiliser sa méthode addAll et de le lire à l'aide de flux. stackoverflow.com/questions/1527519/...
InformationsquelleAutor
146

Si vous n'avez pas de soins sur le fait d'avoir accès par index et vous voulez juste de l'insertion afin de préserver les caractéristiques d'une Liste, vous pourriez envisager une java.util.de façon concomitante.ConcurrentLinkedQueue. Depuis, il met en œuvre Itératif, une fois que vous avez fini d'ajouter tous les éléments, vous pouvez passer en boucle le contenu en utilisant le améliorée pour la syntaxe:
```
Queue<String> globalQueue = new ConcurrentLinkedQueue<String>();

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

for (String href : globalQueue) {
    //do something with href
}
```
- Je pense que la procédure simplifiée de déclaration (:) est appelée foreach: docs.oracle.com/javase/1.5.0/docs/guide/language/foreach.html
- Vous avez raison. Je pense que le nom a toujours dérangé, car la syntaxe n'inclut pas le mot "chaque", mais je vais mettre à jour la réponse à utiliser le nom officiel. 🙂
- Coupant les cheveux en quatre, mais en fonction de la JLS version 8 il est appelé le "renforcement de l'énoncé". De même dans le java tutoriel.
- certainement PAS tatillon. Il est (maintenant) une différence entre "pour chaque" et "améliorée" de Java.
- Faites-vous référence à Stream.forEach?
- indirectement. Je crois qu'ils ont rebaptisé "pour chaque boucle" pour "renforcée" à éliminer la confusion entre le Flux.forEach et ce qui est maintenant connu sous le nom amélioré pour.
- Mis à jour pour refléter le nouveau nom. Merci pour l'aide.
InformationsquelleAutor Matt Passell
123

Vous pouvez très bien utiliser Les Collections.synchronizedList(Liste) si tous vous avez besoin est simple invocation de synchronisation:
```
 List<Object> objList = Collections.synchronizedList(new ArrayList<Object>());
```
- Le résultat de synchronizedList est "synchronisée", mais pas "concurrent". Une question fondamentale que beaucoup de la Liste des opérations, qui sont basées sur un indice -- eux, ne sont pas atomiques et doivent faire partie d'une plus grande exclusion mutuelle de construire.
- OMI, asing un Vector est plus simple plutôt que de Collections.synchronizedList(new ArrayList<Object>()).
- Le résultat de synchronizedList est "synchronisée", mais pas "concurrent".
InformationsquelleAutor Yanick Rochon
43

Parce que l'acte d'acquisition de la position et de l'élément à partir de la position donnée requiert naturellement certains de verrouillage (vous ne pouvez pas avoir la liste des changements structurels entre ces deux opérations).

L'idée même d'une collecte simultanée est que chaque opération sur sa propre est atomique et peut être fait sans autorisation explicite de verrouillage de synchronisation.

Donc l'élément en position n à partir d'une donnée List comme une opération atomique n'a pas trop de sens dans une situation où l'accès simultané est prévu.
- Joachim, je pense que vous frappez le clou sur la tête. Prenons, par exemple, une liste en lecture seule comme une liste concurrente. L'élément à la position N à partir de la liste est non seulement logique, mais c'est le gros du problème. Ainsi, une liste immuable (minuscules L) serait un bon exemple, mais ce n'est pas une Liste (avec les majuscules L). Le CopyOnWriteArrayList est simultanées, mais beaucoup de gens n'aiment pas les performances. Une solution le long des lignes de cordes (string cordes) serait probablement un bon gagnant.
- Très bon point. Mais la Liste de l'OP va utiliser pourrait avoir très spécifiques d'utilisation. E. g. il peut être rempli en simultané de l'environnement, puis "verrouillé" (quoi que cela signifie) et ensuite accessibles en toute sécurité par l'index. Ainsi, dans la première phase de remplissage de cette Liste auront encore besoin d'un thread-safe mise en œuvre. Malheureusement, l'OP n'a pas été précis sur la manière dont la Liste il est à la recherche d'est va être utilisé.
InformationsquelleAutor Joachim Sauer
1

CopyOnWriteArrayList est thread-safe variante de liste de tableaux dans lesquels
tous les mutative opérations (ajout d'éléments, et ainsi de suite) sont mis en œuvre par
faire une nouvelle copie de la sous-matrice.

CopyOnWriteArrayList est un concurrent à l'alternative de la synchronisation de la Liste de implémente la Liste de l'interface et sa partie de java.util.simultanées packageand son un thread-safe collection.
```
public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
```
CopyOnWriteArrayList est sûre et ne pas jeter ConcurrentModificationException lorsque le sous-jacent CopyOnWriteArrayList est modifiée au cours de l'Itération de l'utilisation d'une copie de la liste de tableaux.

C'est ordinairement trop cher parce que la copie de tableau impliqués à chaque opération de mise à jour une copie clonée sera créé. CopyOnWriteArrayList est le meilleur choix seulement pour les grands opération de lecture.
```
/**
         * 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();
            }
        }
```
InformationsquelleAutor vaquar khan
0

Vous avez ces options:
- Collections.synchronizedList(): vous pouvez envelopper un List de mise en œuvre (ArrayList, LinkedList ou d'un 3ème partie de la liste). L'accès à chaque méthode (lecture et écriture) seront protégées à l'aide de synchronized. Lors de l'utilisation de iterator() ou améliorés pour la boucle, vous devez synchroniser manuellement; lors de l'itération, les autres threads sont entièrement bloqué même de la lecture.
- CopyOnWriteArrayList: c'est cher à modifier, mais sans verrouillage à lire. Les itérateurs ne jamais jeter ConcurrentModificationException, ils renvoient un instantané de la liste au moment de l'itérateur de la création, même si la liste est modifiée par un autre thread lors de l'itération. Utile pour rarement mise à jour des listes.
- Vector: très bien comme synchronizedList, mais itération est synchronisé trop. Cependant, les itérateurs pouvez jeter ConcurrentModificationException, si le vecteur est modifié par un autre thread.
Autres options:
- Collections.unmodifiableList(): sans verrouillage, thread-safe, mais non modifiables
- Queue ou Deque pourrait être une alternative si vous avez seulement ajouter/supprimer à la fin de la liste et de réitérer la liste. Il n'y a pas accès indexé et aucun ajout/suppression arbitraire des lieux. Ils ont simultané de plusieurs implémentations avec de meilleures performances et une meilleure parallèle d'accès, mais c'est en dehors de la portée de cette question.
InformationsquelleAutor Oliv

Vous devez vous connecter pour publier un commentaire.