La meilleure façon de prévenir les modifications simultanées exception

Voici le pseudo-code comme suit.

public class MyObject
{   
    private List<Object> someStuff;
    private Timer timer;

    public MyObject()
    {
        someStuff = new ArrayList<Object>();

        timer = new Timer(new TimerTask(){

            public void run()
            {
                for(Object o : someStuff)
                {
                    //do some more stuff involving add and removes possibly
                }
            }
        }, 0, 60*1000);
    }

    public List<Object> getSomeStuff()
    {
        return this.someStuff;
    }
}

Donc, essentiellement, le problème est que d'autres objets ne figurant pas dans le code ci-dessus appel getSomeStuff() pour obtenir la liste de lecture seule. Je suis concurrentmodificationexception dans le thread horloge lorsque cela se produit. J'ai essayé de faire le getSomeStuff méthode synchronisée, et même essayé de blocs synchronisés dans le thread horloge, mais toujours gardé l'obtention de l'erreur. Quelle est la méthode la plus simple de l'arrêt de l'accès simultané de la liste?

OriginalL'auteur thatidiotguy | 2012-04-18

  1. 12

    Vous pouvez utiliser java.util.concurrent.CopyOnWriteArrayList ou en faire une copie (ou obtenir un tableau avec Collection.toArray méthode) avant l'itération de la liste dans le fil.

    En outre, le retrait dans un chaque la construction des pauses itérateur, il n'est donc pas un moyen valable de processus de la liste dans ce cas.

    Mais vous pouvez effectuer les opérations suivantes:

    for (Iterator<SomeClass> i = list.iterator(); i.hasNext();) {
    SomeClass next = i.next();
    if (need_to_remove){
       i.remove(i);                
    }
}

    ou 

    for (int i = list.size() - 1; i >= 0; i--){            
    if (need_to_remove) {
        list.remove(i);                
    }
}

    Est aussi à noter que si votre code accède à la liste de différents threads et la liste est modifiée, vous devez le synchroniser. Par exemple:

        private final ReadWriteLock lock = new ReentrantReadWriteLock();


    final Lock w = lock.writeLock();
    w.lock();
    try {
        //modifications of the list
    } finally {
        w.unlock();
    }

      .................................

    final Lock r = lock.readLock();
    r.lock();
    try {
        //read-only operations on the list
        //e.g. copy it to an array
    } finally {
        r.unlock();
    }
    //and iterate outside the lock

    Mais remarque, que les opérations dans les serrures doivent être aussi courts que possible.

    Mais, le travail effectué dans le thread (ajouter et supprime) persistent dans la liste d'objets. Je ne veux pas que les autres threads d'accéder à la liste de lecture (boucle foreach) à cause de la JVM à paniquer.
    ok, voir mes mises à jour concernant la suppression/itération pour les listes.
    Je crois que j'ai senti que de faire quelque chose avec Java synchroniser mot-clé aurait été possible, mais vous avez dit que ce n'est pas le cas? Et quels paquets sont ces Verrouillage et ReadWriteLock? Aussi, j'ai juste besoin de verrouiller la liste elle-même lors de l'exécution de la méthode dans le timer est en cours d'exécution, est-ce l'approche que vous recommandez?
    Correct. La façon dont vous itérez/supprimer allait se briser en un seul fil de l'environnement. La serrure de la classe en java.util.simultanées paquet. Vous verrouillez pas la liste, mais l'accès. I. e. les opérations avec la liste sont effectuées à l'intérieur des écluses (bien qu'il y est une différence entre lire et écrire opération afin que les lecteurs de ne pas se bloquer les uns les autres).
    Je ne vois rien dans le code qui mentionne la liste à tous. Vous êtes juste la construction de ce verrou de l'objet, mais la liste n'est jamais mentionné. Est-il prévenir TOUTE écriture sur n'importe quel objet?

    OriginalL'auteur Eugene Retunsky

  2. 4

    Vous devez faire une copie de la liste dans getSomeStuff(). La publication d'une référence à un champ privé, comme cela le rend efficace du public, de sorte qu'il n'est pas quelque chose que vous voulez faire de toute façon.

    Aussi, envisager un retour une copie comme une ImmutableList ou au moins comme un inmodifiable liste.

    Ce que je suis en train de faire maintenant, c'est de revenir à des Collections.synchronizedList (qui ne fonctionne pas). Les objets qui reçoivent la liste devrait être en mesure d'itérer dessus pour lire, mais qui est-il. Serait une de ces résoudre le concurrentmodificationexception problème? Le Point pris sur la sécurité de l'objet.

    OriginalL'auteur Adam Zalcman