Ho un ArrayList che desidero utilizzare per contenere oggetti RaceCar che estendono la classe Thread non appena hanno terminato l'esecuzione. Una classe, denominata Race, gestisce questo ArrayList utilizzando un metodo di callback che l'oggetto RaceCar chiama al termine dell'esecuzione. Il metodo di callback, addFinisher (RaceCar finisher), aggiunge l'oggetto RaceCar all'ArrayList. Questo dovrebbe fornire l'ordine in cui i thread terminano l'esecuzione.

So che ArrayList non è sincronizzato e quindi non è thread-safe. Ho provato a utilizzare il metodo Collections.synchronizedCollection (c Collection) passando un nuovo ArrayList e assegnando la Collection restituita a un ArrayList. Tuttavia, questo mi dà un errore del compilatore:

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

Ecco il codice pertinente:

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);
    }

Quello che devo sapere è se sto usando un approccio corretto e, in caso contrario, cosa dovrei usare per rendere il mio codice thread-safe? Grazie per l'aiuto!

Usa Collections.synchronizedList().

Ex:

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

Modificare

private ArrayList finishingOrder;

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

per

private List finishingOrder;

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

List è un supertipo di ArrayList quindi è necessario specificarlo.

Altrimenti, quello che stai facendo sembra a posto. Un'altra opzione è che puoi usare Vector, che è sincronizzato, ma questo è probabilmente quello che farei io.

CopyOnWriteArrayList

Usa CopyOnWriteArrayListclasse. Questa è la versione thread-safe di ArrayList.

Si potrebbe essere utilizzando l'approccio sbagliato. Solo perché un thread che simula un'auto finisce prima di un altro thread di simulazione di un'auto, non significa che il primo thread debba vincere la gara simulata.

Dipende molto dalla tua applicazione, ma potrebbe essere meglio avere un thread che calcoli lo stato di tutte le auto a piccoli intervalli di tempo fino al termine della gara. Oppure, se preferisci utilizzare più thread, potresti fare in modo che ciascuna macchina registri il tempo "simulato" impiegato per completare la gara e scegli il vincitore come quello con il tempo più breve.

Puoi anche usare la synchronizedparola chiave per un addFinishermetodo come questo

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

Quindi puoi usare ArrayList aggiungi il metodo thread-safe in questo modo.

Ogni volta che si desidera utilizzare la versione ant thread safe dell'oggetto raccolta ant, consultare il pacchetto java.util.concurrent. * . Ha quasi tutte le versioni simultanee di oggetti di raccolta non sincronizzati. ad esempio: per ArrayList, hai java.util.concurrent.CopyOnWriteArrayList

Puoi fare Collections.synchronizedCollection (qualsiasi oggetto di raccolta), ma ricorda questo classico synchr. la tecnica è costosa e comporta un sovraccarico di prestazioni. Il pacchetto java.util.concurrent. * è meno costoso e gestisce le prestazioni in modo migliore utilizzando meccanismi come

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

Quindi, preferisci qualcosa dal pacchetto java.util.concurrent. *

Puoi anche usare come vettore invece, poiché i vettori sono thread-safe e gli arraylist non lo sono. Anche se i vettori sono vecchi, possono risolvere facilmente il tuo scopo.

Ma puoi sincronizzare il tuo Arraylist come il codice dato questo:

Collections.synchronizedList(new ArrayList(numberOfRaceCars())); 

Puoi cambiare da ArrayList a Vector, in cui ogni metodo è sincronizzato.

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