Effectively Immutable Object
concurrency, immutability, java, java-memory-model
Solution
Yes. The write operations on the `MutableLong` are followed by a `happens-before` relationship (on the volatile) before the read.
(It is possible that a thread reads `Outworld.published` and passes it on to another thread unsafely. In theory, that could see earlier state. In practice, I don't see it happening.)
Problem
I want to make sure that I correctly understand the 'Effectively Immutable Objects' behavior according to Java Memory Model. Let's say we have a mutable class which we want to publish as an effectively immutable: ``` class Outworld { // This MAY be accessed by multiple threads public static volatile MutableLong published; } // This class is mutable class MutableLong { private long value; public MutableLong(long value) { this.value = value; } public void increment() { value++; } public long get() { return value; } } ``` We do the following: ``` // Create a mutable object and modify it MutableLong val = new MutableLong(1); val.increment(); val.increment(); // No more modifications // UPDATED: Let's say for this example we are completely sure // that no one will ever call increment() since now // Publish it safely and consider Effectively Immutable Outworld.published = val; ``` The question is: Does Java Memory Model guarantee that all threads MUST have `Outworld.published.get() == 3` ? According to Java Concurrency In Practice this should be true, but please correct me if I'm wrong. 3.5.3. Safe Publication Idioms To publish an object safely, both the reference to the object and the object's state must be made visible to other threads at the same time. A properly constructed object can be safely published by: - Initializing an object reference from a static initializer; - Storing a reference to it into a volatile field or AtomicReference; - Storing a reference to it into a final field of a properly constructed object; or - Storing a reference to it into a field that is properly guarded by a lock. 3.5.4. Effectively Immutable Objects Safely published effectively immutable objects can be used safely by any thread without additional synchronization.