Java Concurrency - Write and Read Reference Atomicity
Can a reference half written to the memory? Can a reference half read from the memory?
Write and Read Reference Atomicity
In Java, writing a reference to memory is indeed atomic. This means that the operation of assigning a new value to a reference variable happens as a single, indivisible action. It is guaranteed that no thread can observe a partially written reference.
A reference write will either store the complete new address or retain the old one; there’s no intermediate state where the reference holds a corrupted or half-written address. This atomicity applies regardless of whether the reference is 32-bit or 64-bit.
However, it’s crucial to distinguish this from the atomicity of operations on the object being referenced. While the reference write itself is atomic, modifications to the object’s state through that reference may not be, requiring proper synchronization mechanisms like locks or volatile variables to ensure thread safety.
non-volatile long and double
For non-volatile long and double, the JVM may split the write into two 32-bit writes. This means that another thread could see a half-written long or double value.
For Example, a non-volatile long has initial value V1. Thread T1 writes a new value V2 to the long. The JVM may split the write into two 32-bit writes, writing the lower 32 bits first and then the upper 32 bits. If another thread T2 reads the long value during the write operation, it may see value V1 or V2 or a corrupted value - a mix of V1 and V2.
volatile long and double are always atomic. The JVM guarantees that writes to volatile long and double are always atomic, regardless of the underlying hardware architecture.
On the other hand, Primitive types like int, short, byte, char, float, boolean, and references are always atomic, regardless of whether they are volatile or not.
Reference