Is the != check thread safe?

Question

I know that compound operations such as `i++` are not thread safe as they involve multiple operations. But is checking the reference with itself a thread safe operation? ``` a != a //is this thread-safe ``` I tried to program this and use multiple threads but it didn't fail. I guess I could not simulate race on my 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(); } } ``` This is the program that…

Accepted Answer

In the absence of synchronization this code

```
Object a;

public boolean test() {
    return a != a;
}
```

may produce `true`. This is the bytecode for `test()`

```
    ALOAD 0
    GETFIELD test/Test1.a : Ljava/lang/Object;
    ALOAD 0
    GETFIELD test/Test1.a : Ljava/lang/Object;
    IF_ACMPEQ L1
...
```

as we can see it loads field `a` to local vars twice, it's a non-atomic operation, if `a` was changed in between by another thread comparison may produce `false`.

Also, memory visibility problem is relevant here, there is no guarantee that changes to `a` made by another thread will be visible to the current thread.

Is the != check thread safe?

Solution

Problem

Related problems