Re: Synchronization Question

From:

Lew <noone@lewscanon.com>

Newsgroups:

comp.lang.java.programmer

Date:

Tue, 15 Sep 2009 00:49:52 -0400

Message-ID:

<h8n6dh$ohd$1@news.albasani.net>

Knute Johnson wrote:

I can only refer you to Java Concurrency in Practice, by Brian Goetz
et al. "The visibility effects of volatile variables extend beyond
the value of the volatile variable itself. When thread A writes to a
volatile variable and subsequently thread B reads that same variable,
the values of all variables that were visible to A prior to writing to
the volatile variable become visible to B after reading the volatile
variable."

markspace wrote:

That's a good find. I just re-read the JLS and I think it supports the
opposite conclusion, but surely there something I'm missing.

The JLS defines "actions" (which later become "synchronization actions")
as a tuple with four elements. Element "v" is:

"v - the variable or monitor involved in the action. For lock actions, v
is the monitor being locked; for unlock actions, it is the monitor being
unlocked. If the action is ----> _*(volatile or non-volatile) read, v is
the variable being read. If the action is a (volatile or non-volatile)
write, v is the variable being written*_ <----"

Emphasis mine.

Later the JLS defines "happens-before" in terms of those tuples. Then
it has the following "discussion:"

"A write to a volatile field (??8.3.1.4) happens-before every subsequent
read of that field. "

The "that field" bit seemed to indicate that it was only the one field
that got synchronized. I'll go hit up JCiP and see what I can find there.

From JLS ??17.4.5:

If we have two actions x and y, we write
hb(x, y) to indicate that x happens-before y.

* If x and y are actions of the same thread
  and x comes before y in program order,
  then hb(x, y).

* There is a happens-before edge
  from the end of a constructor of an object
  to the start of a finalizer (??12.6) for that object.

* If an action x synchronizes-with a following action y,
  then we also have hb(x, y).

* If hb(x, y) and hb(y, z), then hb(x, z).

The relation /happens-before/ holds for variables other than the 'volatile'
due to that last rule, transitivity.

given volatile 'v' and non-volatile 'w':

  - write to w: W(w)
  - write to v: W(v)

W(w) happens-before W(v)

Other thread, later:

  - read from v: R(v)
  - read from w: R(w)

W(v) happens-before R(v)
R(v) happens-before R(w)

ergo, W(w) happens-before R(w)

--
Lew