Re: Synchronization Question
Knute Johnson wrote:
Each of the OPs array modifying threads would write to a common
volatile variable as the last action before terminating. Prior to
reading the array, the reading thread reads the common volatile
variable and all variables written to by the writing threads will be
now be visible to the reading thread.
markspace wrote:
Hmm, I didn't re-read the JLS, but off the top of my head this won't work.
It will work for Java 5+. This is the major difference in the semantics of
the memory model for 'volatile' between Java 1.4 and Java 5.
Volatile variables only have a happens-before relationship for
themselves, i.e., only for reads/writes to that one variable. That's
why they are cheaper than regular synchronization, which has to flush
all writes.
There's no synchronization (happens-before) relationship between
different volatile variables, or for other read/writes in a thread.
That was true prior to Java 5, the first version to apply the term
'happens-before'. One significant change in 5+ to the memory model is that
all writes prior to a write to a 'volatile' variable /happen-before/ a
subsequent read of the volatile variable, and also /happen-before/ all reads
subsequent to that read of the volatile variable transitively. In simpler words,
public class NotTested
{
volatile int v;
/* not volatile */ int w;
public final void setState( int value )
{
w = value;
v = (value | 1);
}
public final int getState()
{
return (this.v == 0? this.w : -this.w);
}
}
It's a bit silly, but what I'm going for is that a client who calls getState()
should see all prior writes to w.
--
Lew