Re: What does volatile guarantee?
On 13-02-2010 13:40, Peter Duniho wrote:
Arne Vajh?j wrote:
I believe that current JLS still does not guarantee
atomicity of reading/writing long and double.
Those being primitive types, it does. Lew even described the relevant
"volatile" rule in his earlier reply:
Lew wrote:
> [...]
> - Reads from and writes to 'x' are atomic, whether that variable
> represents any primitive including 'long' or 'double', or a reference.
Section 17.7 in the JLS states:
<quote>
Some implementations may find it convenient to divide a single write
action on a 64-bit long or double value into two write actions on
adjacent 32 bit values. For efficiency's sake, this behavior is
implementation specific; Java virtual machines are free to perform
writes to long and double values atomically or in two parts.
For the purposes of the Java programming language memory model, a single
write to a non-volatile long or double value is treated as two separate
writes: one to each 32-bit half. This can result in a situation where a
thread sees the first 32 bits of a 64 bit value from one write, and the
second 32 bits from another write. Writes and reads of volatile long and
double values are always atomic. Writes to and reads of references are
always atomic, regardless of whether they are implemented as 32 or 64
bit values.
VM implementors are encouraged to avoid splitting their 64-bit values
where possible. Programmers are encouraged to declare shared 64-bit
values as volatile or synchronize their programs correctly to avoid
possible complications.
<quote>
Lew is talking about volatile long's, which is not what we are
discussing here (volatile long's has been atomic since 1.0).
Arne