From the Java Memory Model specification:
An object is considered to be completely initialized when its constructor finishes. A thread that can only see a reference to an object after that object has been completely initialized is guaranteed to see the correctly initialized values for that object's final fields.
The part that confuses me is this sentence:
A thread that can only see a reference to an object after that object has been completely initialized is guaranteed to see the correctly initialized values for that object's final fields.
The subject of the sentence is
A thread that can only see a reference to an object after that object has been completely initialized
The rest of the statement applies only to this subject. This suggests to me that there are some threads that can see a reference to an object before that object has been completely initialized.
If such threads exist, then the guarantee relating to final fields in this specification only applies in some cases.
In an old Brian Goetz article from 2001, Goetz describes a scenario:
Suppose thread B comes along after the memory has been allocated and the resource field is set, but before the constructor is called. It sees that resource is not null, skips the synchronized block, and returns a reference to a partially constructed Resource!
This suggests that there are in fact threads out there that can see references to objects before they are completely initialized.
Goetz then goes on to explain how using volatile doesn't help get around this problem, either.
So, how do I guarantee that some Object B cannot see some new ObjectA before ObjectA is completely initialized? It seems using final fields only helps if these conditions are already satisfied.