Turns out that the answers and the ensuing discussions only consolidated my original reasoning. I now have something in the way of a proof: take the case where the reading thread executes in full before the writing thread starts executing; note the synchronization order that this particular run created; now shift the threads in wall-clock … Read more
No, you will never get a NPE. This is because volatile also has the memory-effect of introducing a happens-before relationship. In other words, it will prevent reordering of a = one; b = two; The statements above, will not be re-ordered, and all threads will observe value one for a if b already has value … Read more
i = 1 always happens-before v = 2 True. By JLS section 17.4.5, If x and y are actions of the same thread and x comes before y in program order, then hb(x, y). v = 2 happens-before vDst = v in JMM only if it’s actually happens before in time i = 1 happens-before … Read more
As already pointed out it’s absolutely thread-safe, and final is important here due to its memory visibility effects. Presence of final guarantees that other threads would see values in the map after constructor finished without any external synchronization. Without final it cannot be guaranteed in all cases, and you would need to use safe publication … Read more
Short of reading the memory model specification, I recommend you read http://jeremymanson.blogspot.com/2008/11/what-volatile-means-in-java.html. It’s written by one of the JMM authors and should answer your question. Thinking of memory reads and writes in terms of the happens-before clause is also helpful; the JMM for Java 5 onwards adds happens-before semantics to volatile. Specifically, when you read … Read more
As of 4.0 (Ice Cream Sandwich), Dalvik’s behavior should match up with JSR-133 (the Java Memory Model). As of 3.0 (Honeycomb), most of the pieces were in place, but some minor things had been overlooked that would be difficult to encounter in practice (e.g. some edge cases in finalization). As of 2.3 (Gingerbread), Dalvik was … Read more
The key point of the program order rule is: in a thread. Imagine this simple program (all variables initially 0): T1: x = 5; y = 6; T2: if (y == 6) System.out.println(x); From T1’s perspective, an execution must be consistent with y being assigned after x (program order). However from T2’s perspective this does … Read more
The short answer is that JSR-133 goes too far in its explanation. This isn’t a serious issue because JSR-133 is a non-normative document which isn’t part of the language or JVM standards. Rather, it is only a document which explains one possible strategy that is sufficient for implementing the memory model, but isn’t in general … Read more
If you look at the underlying array reference you’ll see it’s marked as volatile. When a write operation occurs (such as in the above extract) this volatile reference is only updated in the final statement via setArray. Up until this point any read operations will return elements from the old copy of the array. The … Read more
The main difference between an immutable object (all properties final) and an effectively immutable object (properties aren’t final but can’t be changed) is safe publication. You can safely publish an immutable object in a multi threaded context without having to worry about adding synchronization, thanks to the guarantees provided by the Java Memory Model for … Read more