java-memory-model

In Java Concurrency In Practice, the author stated that Immutable objects can be published through any mechanism Immutable objects can be used safely by any thread without additional synchronization, even when synchronization is not used to publish them. Does it mean that the following idioms are safe to publish immutable objects? public static List<ImmutableObject> list = new ArrayList<ImmutableObject>(); // thread A invokes this method first public static void methodA () { list.add(new ImmutableObject()); } // thread B invokes this method later public static ImmutableObject methodB () {

say we have this // This is trivially immutable. public class Foo { private String bar; public Foo(String bar) { this.bar = bar; } public String getBar() { return bar; } } What makes this thread unsafe ? Following on from this question . Foo is thread safe once it has been safely published. For example, this program could print "unsafe" (it probably won't using a combination of hotspot/x86) - if you make bar final it can't happen: public class UnsafePublication { static Foo foo; public static void main(String[] args) { new Thread(new Runnable() { @Override public void run() { while (foo ==

I've looked at this answer , and it states how: Under the new memory model, when thread A writes to a volatile variable V, and thread B reads from V, any variable values that were visible to A at the time that V was written are guaranteed now to be visible to B. Therefore, given the example: public class Main { static int value = -1; static volatile boolean read; public static void main(String[] args) { Thread a = new Thread(() -> { value = 1; read = true; }); Thread b = new Thread(() -> { while (!read); System.out.println("Value: " + value); }); a.start(); b.start(); } } Is the change to

Program order rule states "Each action in a thread happens-before every action in that thread that comes later in the program order" 1.I read in another thread that an action is reads and writes to variables locks and unlocks of monitors starting and joining with threads Does this mean that reads and writes can be changed in order, but reads and writes cannot change order with actions specified in 2nd or 3rd lines? 2.What does "program order" mean? Explanation with an examples would be really helpful. Additional related question Suppose I have the following code: long tick = System.nanoTime();

I try to understand why this example is a correctly synchronized program: a - volatile Thread1: x=a Thread2: a=5 Because there are conflicting accesses (there is a write to and read of a) so in every sequential consistency execution must be happens-before relation between that accesses. Suppose one of sequential execution: 1. x=a 2. a=5 Is 1 happens-before 2, why? No, a volatile read before (in synchronization order) a volatile write of the same variable does not necessarily happens-before the volatile write. This means they can be in a "data race", because they are "conflicting accesses not

Can some one explain initialization safety as required by Java memory model ? How does the final fields help in achieving initialization safety ? What role does the constructor play in ensuring initialization safety ? Initialization safety provides for an object to be seen by an external thread in its fully constructed ( initialized ) state. The prerequisite is that the object should not be published prematurely ie. in its constructor. Once this is ensured , JMM requires certain behaviour for the fields that are declared as final . First , all final object fields are guarenteed to be seen by