Question

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.

Answer 1

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.)