Sé que las operaciones compuestas, como i++no son seguras para subprocesos, ya que implican múltiples operaciones.
¿Pero verificar la referencia consigo mismo es una operación segura para subprocesos?
a != a //is this thread-safeTraté de programar esto y usar múltiples hilos pero no falló. Supongo que no podría simular la carrera en mi máquina.
EDITAR:
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();
}
}
Este es el programa que estoy usando para probar la seguridad del hilo.
Comportamiento extraño
Cuando mi programa comienza entre algunas iteraciones, obtengo el valor del indicador de salida, lo que significa que la !=verificación de referencia falla en la misma referencia. PERO después de algunas iteraciones, la salida se convierte en un valor constante falsey luego ejecutar el programa durante mucho tiempo no genera una sola truesalida.
Como sugiere la salida después de algunas iteraciones n (no fijas), la salida parece ser un valor constante y no cambia.
Salida:
Para algunas iteraciones:
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
1234:truenunca se rompen entre sí ). Una prueba de carrera necesita un circuito interno más ajustado. Imprima un resumen al final (como alguien hizo a continuación con un marco de prueba de unidad).