Re: Volatile happens before question
On 1/17/12 4:04 AM, raphfrk@gmail.com wrote:
The spec says that all writes to volatiles can be considered to happen
before all subsequent reads. What does "subsequent" mean, is that
with regards to real time?
So,
Thread 1
int b = 0;
volatile boolean a = false;
...
...
b = 1;
a = true;
Thread 2
if (a) {
System.out.println("The value of b is " + b);
}
Since the setting of a to true happens before the reading of a as
true, the println must happen after b is set to 1.
This means that either nothing will be printed or "The value of b is
1" will be printed.
This works as you expect, yes...
Does this work in reverse too?
Not exactly.
For example,
Thread 1
int b = 0;
volatile boolean a = false;
...
...
a = true;
b = 1;
Thread 2
int bStore = b;
if (!a) {
System.out.println("The value of b is " + bStore);
}
Will this always print either "The value of b is 0" or nothing.
(bStore = b) happens before (read a as false)
(read a as false) happens before (set a = true) [is this valid?]
(set a = true) happens before (set b = 1)
I see no flaw in your reasoning here, though it isn't the "reverse" of
the previous case, it is exactly the same.
So, bStore = b happens before set b = 1, so bStore = 0.
Effectively, the rule would be "A read to a volatile happens before
the write to that volatile that overwrites the value that was read".
Yes. that is true.
However, that wasn't clear from the spec. I think since read/writes
to volatiles are synchronization actions, then when running the
program, they can be considered to have happened in some ordering
(consistent with program order in the threads). As long as the
program works no matter what the ordering is picked, then it is fine.
Yes, that is part of the point.
You may wish to invest in a copy of the book "Java Concurrency in
Practice". It is very thorough, explicit, and understandable explanation
of program behavior under concurrent situations.