Is id = 1 - id atomic?

Am I wrong?

Nope, you're absolutely right - as is your example timeline.

In addition to it not being atomic, it's not guaranteed that the write to id will be picked up by the other thread anyway, given that there's no synchronization and the field isn't volatile.

It's somewhat disconcerting for reference material like this to be incorrect :(

In my opinion, the answer in the Practice Exams is correct. In this code, you are executing two threads which have access to the same static variable id. Static variables are stored on the heap in java, not on the stack. The execution order of runnables is unpredictable.

However, in order to change the value of id each thread :

1. makes local copy of the value stored in id's memory address to the CPU registry;
2. performs the operation 1 - id. Strictly speaking, two operations are performed here (-id and +1);
3. moves the result back to memory space of id on the heap.

This means that although the id value can be changed concurrently by any of the two threads, only the initial and final values are mutable. Intermediate values will not be modified by one another.

Futhermore, analysis of the code can show that at any point in time, id can only be 0 or 1.

Proof:

• Starting value id = 1;One thread will change it to 0 ( id = 1 - id ). And the other thread will bring it back to 1.

• Starting value id = 0;One thread will change it to 1 ( id = 1 - id ). And the other thread will bring it back to 0.

Therefore, the value state of id is discrete either 0 or 1.

End of Proof.

There can be two possibilities for this code:

• Possibility 1. Thread one accesses the variable id first. Then the value of id (id = 1 - id changes to 0. Thereafter, only the method pick () will be executed, printing P Q. Thread two, will evaluate id at that time id = 0; method release() will then be executed printing R S. As a result, P Q R S will be printed.

• Possibility 2. Thread two accesses the variable id first. Then the value of id (id = 1 - id changes to 0. Thereafter, only the method pick () will be executed, printing P Q. Thread one, will evaluate id at that time id = 0; method release() will then be executed printing R S. As a result, P Q R S will be printed.

There are no other possibilities. However, it should be noted that variants of P Q R S such as P R Q S or R P Q S, etc. may be printed due to pick() being a static method and is therefore shared between the two threads. This leads to the simultaneous execution of this method which could result in printing the letters in a different order depending on your platform.

However in any case, never will either the method pick() or release () be executed twice as they are mutually exclusive. Therefore P Q P Q will not be an output.