Je sais que le composé opérations telles que l' i++ ne sont pas thread-safe, car elles comportent de multiples opérations.
Mais est la vérification de la référence à lui-même un "thread-safe" opération?
a != a //is this thread-safe
J'ai essayé de programmer et d'utiliser plusieurs threads, mais il ne l'a pas manqué. Je suppose que je ne pouvais pas simuler course sur ma machine.
EDIT:
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();
}
}
C'est le programme que j'utilise pour tester le fil de sécurité.
Le comportement bizarre
Comme mon programme commence entre quelques itérations-je obtenir de l'indicateur de sortie de valeur, ce qui signifie que la référence != vérification échoue sur la même référence. MAIS après quelques itérations, la sortie devient la valeur de la constante false et d'exécuter le programme pour un long temps ne génère pas un seul true de la production.
Comme la sortie suggère après certains n (non fixe) itérations de la sortie semble être la valeur de la constante et ne change pas.
Sortie:
Pour quelques itérations:
1494:true
1495:true
1496:true
19970:true
19972:true
19974:true
//after this there is not a single instance when the condition becomes true
