安全初始化非最终字段

Question

From Java theory and practice: Fixing the Java Memory Model, Part 2

The new JMM also seeks to provide a new guarantee of initialization safety -- that as long as an object is properly constructed (meaning that a reference to the object is not published before the constructor has completed), then all threads will see the values for its final fields that were set in its constructor, regardless of whether or not synchronization is used to pass the reference from one thread to another.

So what is about non final fields initialized in constructor? From a reference to the object is not published before the constructor has completed I could conclude that behaviour is same as for final fields. Is it correct?

Answer 1

Take this simple class:

class Example {
    final int i;
    int j;
    Example() { i = 5; j = 5; }
}

No reference to the object is published during construction, so the JMM guarantees that all reading threads that access a newly created instance of Example will see i = 5 . That is the case regardless of how the instance is published.

Those same threads might however see j = 0 (ie the default value) if the instance is not published safely. Safe publication idioms include:

• initialising the instance from a static initialiser
• marking the reference to the instance as volatile
• marking the reference to the instance as final
• synchronizing all accesses

Answer 2

• For volatile variables, writes are guaranteed to be immediately visible to all threads. This is the case whether or not the write was done in a constructor.

• For non-volatile variables, writes may not immediately be visible to other threads. This is the case whether or not the write was done in a constructor.

A special case is final fields. Writes to an object's final fields are guaranteed to be visible to all threads once the constructor has been completed.

You can read more here .