Comment rendre mon ArrayList thread-safe? Une autre approche du problème en Java?

Question

J'ai une ArrayList que je veux utiliser pour contenir des objets RaceCar qui étendent la classe Thread dès qu'ils sont terminés. Une classe, appelée Race, gère cette ArrayList à l'aide d'une méthode de rappel que l'objet RaceCar appelle lorsque l'exécution est terminée. La méthode de rappel, addFinisher (finisseur RaceCar), ajoute l'objet RaceCar à ArrayList. Ceci est supposé donner l'ordre dans lequel les Threads finissent d'être exécutés.

Je sais que ArrayList n'est pas synchronisé et n'est donc pas sûr pour les threads. J'ai essayé d'utiliser la méthode Collections.synchronizedCollection (c Collection) en transmettant une nouvelle ArrayList et en affectant la Collection retournée à une ArrayList. Cependant, cela me donne une erreur de compilation:

Race.java:41: incompatible types 
found : java.util.Collection 
required: java.util.ArrayList 
finishingOrder = Collections.synchronizedCollection(new ArrayList(numberOfRaceCars)); 

Voici le code correspondant:

public class Race implements RaceListener { 
    private Thread[] racers; 
    private ArrayList finishingOrder; 

    //Make an ArrayList to hold RaceCar objects to determine winners 
    finishingOrder = Collections.synchronizedCollection(new ArrayList(numberOfRaceCars)); 

    //Fill array with RaceCar objects 
    for(int i=0; i<numberOfRaceCars; i++) { 
    racers[i] = new RaceCar(laps, inputs[i]); 

     //Add this as a RaceListener to each RaceCar 
     ((RaceCar) racers[i]).addRaceListener(this); 
    } 

    //Implement the one method in the RaceListener interface 
    public void addFinisher(RaceCar finisher) { 
     finishingOrder.add(finisher); 
    } 

Ce que je dois savoir est, que j'utilise une approche correcte et sinon, que dois-je utiliser pour rendre mon code thread-safe? Merci pour l'aide!

Answer 1

Utilisez Collections.synchronizedList().

Ex:

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

Answer 2

changement

private ArrayList finishingOrder; 

//Make an ArrayList to hold RaceCar objects to determine winners 
finishingOrder = Collections.synchronizedCollection(new ArrayList(numberOfRaceCars) 

à

private List finishingOrder; 

//Make an ArrayList to hold RaceCar objects to determine winners 
finishingOrder = Collections.synchronizedList(new ArrayList(numberOfRaceCars) 

Liste est un super-type de ArrayList donc vous devez le préciser.

Sinon, ce que vous faites semble bien. Une autre option est que vous pouvez utiliser Vector, qui est synchronisé, mais c'est probablement ce que je ferais.

Answer 3

Vous pouvez changer de type ArrayList vecteur, dans lequel chaque méthode est synchronisée.

private Vector finishingOrder; 
//Make a Vector to hold RaceCar objects to determine winners 
finishingOrder = new Vector(numberOfRaceCars); 

Answer 4

Vous pourriez être en utilisant la mauvaise approche. Tout simplement parce qu'un fil qui simule une voiture finit avant un autre thread de simulation de voiture ne signifie pas que le premier fil devrait gagner la course simulée.

Cela dépend beaucoup de votre application, mais il peut être préférable d'avoir un thread qui calcule l'état de toutes les voitures à de petits intervalles de temps jusqu'à la fin de la course. Ou, si vous préférez utiliser plusieurs threads, vous pouvez demander à chaque voiture d'enregistrer le temps «simulé» nécessaire pour terminer la course, et choisir le vainqueur comme étant le plus court.

Answer 5

Vous pouvez également utiliser synchronized mot-clé pour addFinisher méthode comme celle

//Implement the one method in the RaceListener interface 
    public synchronized void addFinisher(RaceCar finisher) { 
     finishingOrder.add(finisher); 
    } 

avec cette façon, vous pouvez donc utiliser la méthode ArrayList ajouter thread-safe.

Answer 6

CopyOnWriteArrayList

Utilisez la classe CopyOnWriteArrayList. Ceci est la version sans risque de thread de ArrayList.

Answer 7

Chaque fois que vous voulez utiliser du fil fourmi version sécurisée de l'objet de collection de fourmis, prendre l'aide de java.util.concurrent. * Package. Il a presque toute la version simultanée d'objets de collection non synchronisés. Par exemple: pour ArrayList, vous avez java.util.concurrent.CopyOnWriteArrayList

Vous pouvez faire Collections.synchronizedCollection (n'importe quel objet de collection), mais souvenez-vous de ce synchr. La technique est coûteuse et vient avec des frais généraux de performance. java.util.concurrent. * Forfait est moins cher et gérer les performances d'une meilleure manière en utilisant des mécanismes comme

copy-on-write,compare-and-swap,Lock,snapshot iterators,etc.

Alors, préférez quelque chose de java.util.concurrent. * Package