Re: Synchronization Question
On Sun, 13 Sep 2009, Richard Maher wrote:
"Kenneth P. Turvey" <evoturvey@gmail.com> wrote in message
news:4aacbe8d$0$10721$ec3e2dad@news.usenetmonster.com...
On Sat, 12 Sep 2009 13:34:44 -0700, Patricia Shanahan wrote:
The JLS requires individual int writes to be atomic, so there is no
possibility of a mixed value from two different writes.
Well, that solves that problem.
That is comforting. With no control over memory alignment and RISCesque
load/modify/store operations Java is able to guarantee cross-quadword
atomic writes without additional synchronization?
What makes you think java has no control over memory alignment and no
access to load-modify-store operations (or equivalent tools on chips
lacking them)? The JVM has access to those and more.
I like it! (Bytes as well, or just longwords and up?)
See JLS 17.6, 'Word Tearing':
http://java.sun.com/docs/books/jls/third_edition/html/memory.html#57481
Which sayeth:
One implementation consideration for Java virtual machines is that every
field and array element is considered distinct; updates to one field or
element must not interact with reads or updates of any other field or
element. In particular, two threads that update adjacent elements of a
byte array separately must not interfere or interact and do not need
synchronization to ensure sequential consistency.
Some processors do not provide the ability to write to a single byte. It
would be illegal to implement byte array updates on such a processor by
simply reading an entire word, updating the appropriate byte, and then
writing the entire word back to memory. This problem is sometimes known
as word tearing, and on processors that cannot easily update a single
byte in isolation some other approach will be required.
But beware of section 17.7, 'Non-atomic Treatment of double and long':
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.
tom
--
Also, a 'dark future where there is only war!' ... have you seen the
news lately? -- applez