So che operazioni composte come i++non sono thread-safe in quanto coinvolgono più operazioni.
Ma controllare il riferimento con se stesso è un'operazione sicura del thread?
a != a //is this thread-safeHo provato a programmare questo e usare più thread ma non è fallito. Immagino di non poter simulare la corsa sulla mia macchina.
MODIFICARE:
public class TestThreadSafety {
private Object a = new Object();
public static void main(String[] args) {
final TestThreadSafety instance = new TestThreadSafety();
Thread testingReferenceThread = new Thread(new Runnable() {
@Override
public void run() {
long countOfIterations = 0L;
while(true){
boolean flag = instance.a != instance.a;
if(flag)
System.out.println(countOfIterations + ":" + flag);
countOfIterations++;
}
}
});
Thread updatingReferenceThread = new Thread(new Runnable() {
@Override
public void run() {
while(true){
instance.a = new Object();
}
}
});
testingReferenceThread.start();
updatingReferenceThread.start();
}
}Questo è il programma che sto usando per testare la sicurezza dei thread.
Comportamento strano
Quando il mio programma inizia tra alcune iterazioni, ottengo il valore del flag di output, il che significa che il !=controllo del riferimento fallisce sullo stesso riferimento. MA dopo alcune iterazioni l'output diventa un valore costante falsee quindi l'esecuzione del programma per molto tempo non genera un singolo trueoutput.
Come l'output suggerisce dopo alcune iterazioni n (non fisse) l'output sembra essere un valore costante e non cambia.
Produzione:
Per alcune iterazioni:
1494:true
1495:true
1496:true
19970:true
19972:true
19974:true
//after this there is not a single instance when the condition becomes true1234:truenon distruggere l'altro ). Un test di gara richiede un circuito interno più stretto. Stampa un riepilogo alla fine (come ha fatto qualcuno di seguito con un framework di unit test).