Suppose we have two statements executed by a thread:
(1) x.f = a; (f is non-volatile, x is known not to be null)
(2) y.v = b; (v is volatile field, y is known not to be null)
If statement (1) is executed before statement (2), then (1) hb (2),
and thereby any thread subsequently reading y.v should be certain of
seeing the modified value of x.f. I agree that this is implied by the
However, if statement (2) is executed before statement (1), due to
reordering, then visibility of the modified value of x.f seems not
to be assured by the happens-before rules.
The relevant parts of the document which might help us determine
if statement (2) can be executed before statement (1) seem to be:
Among all the inter-thread actions performed by each thread t, the
program order of t is a total order that re ects the order in which
these actions would be performed according to the intra-thread semantics
Intra-thread semantics are the standard semantics for single threaded
and allow the complete prediction of the behavior of a thread based on the
values seen by read actions within the thread. To determine if the actions
thread t in an execution are legal, we simply evaluate the implementation
thread t as would be performed in a single threaded context, as defined in
remainder of the Java Language Specification.
... If x and y are actions of the same thread and x comes before y in
program order, then x hb y.
The difficulty I am having is that I can't find any language in the
community draft 2 JMM or JLS documents which specify that performing
statement (2) before statement (1) would violate intra-thread
semantics, thereby ( (1) hb (2) ) might not be true (in this case),
thereby visibility of non-volatile field changes made before volatile
write might not be certain (in the general case).
It still seems that this may be a matter of the intentions not being
backed up by the formalism, which would be a real problem when we are
trying to get the model right this time.
But, I am a complete novice in this area and may have missed something
that is painfully obvious to other readers of the JMM / JLS specs :-)
> -----Original Message-----
> From: firstname.lastname@example.org
> [mailto:email@example.com]On Behalf Of Jeremy Manson
> Sent: Friday, 14 November 2003 9:18 a.m.
> To: firstname.lastname@example.org
> Cc: Bill Pugh; Java Memory Model
> Subject: Re: JavaMemoryModel: Question about implementation of
> > Bill (and others),
> > You wrote:
> > "In general, a JVM is not allowed to reorder a volatile
> write with any
> > > preceding accesses to shared memory."
> > Although I found reference to this in the JMM archives, I could not
> > find this statement in the community review 2 JMM document.
> > Is it unintentionally missing from the document?
> It isn't a hard and fast rule. It is simply implied by the fact that all
> the actions before a volatile write have to be visible to any actions
> following a subsequent volatile read on the same variable; this is implied
> by the happens-before rules.
> So, for example, you can do the reordering if no other thread ever reads
> that volatile. Or if they read the volatile, but never see any
> results of
> the access being reordered.
> JavaMemoryModel mailing list -
JavaMemoryModel mailing list - http://www.cs.umd.edu/~pugh/java/memoryModel
This archive was generated by hypermail 2b29 : Thu Oct 13 2005 - 07:00:53 EDT