If another thread were to check the someObject
variable "during" construction, I believe it may (due to quirks in the memory model) see a partially initialized object. The new (as of Java 5) memory model means that any final fields should be set to their values before the object becomes visible to other threads (so long as the reference to the newly created object doesn't escape from the constructor in any other way) but beyond that there aren't many guarantees.
Basically, don't share data without appropriate locking (or guarantees given by static inializers etc) :) Seriously, memory models are seriously tricky, as is lock-free programming in general. Try to avoid this becoming a possibility.
In logical terms the assignment happens after the constructor runs - so if you observe the variable from the same thread it will be null during the constructor call. However, as I say there are memory model oddities.
EDIT: For the purposes of double-checked locking, you can get away with this if your field is volatile
and if you're using Java 5 or higher. Prior to Java 5 the memory model wasn't strong enough for this. You need to get the pattern exactly right though. See Effective Java, 2nd edition, item 71 for more details.
EDIT: Here's my reasoning for arguing against Aaron's inlining being visible in a single thread. Suppose we have:
public class FooHolder
{
public static Foo f = null;
public static void main(String[] args)
{
f = new Foo();
System.out.println(f.fWasNull);
}
}
// Make this nested if you like, I don't believe it affects the reasoning
public class Foo
{
public boolean fWasNull;
public Foo()
{
fWasNull = FooHolder.f == null;
}
}
I believe this will always report true
. From section 15.26.1:
Otherwise, three steps are required:
- First, the left-hand operand is evaluated to produce a variable. If this evaluation completes
abruptly, then the assignment
expression completes abruptly for the
same reason; the right-hand operand is
not evaluated and no assignment
occurs.
- Otherwise, the right-hand operand is evaluated. If this
evaluation completes abruptly, then
the assignment expression completes
abruptly for the same reason and no
assignment occurs.
Otherwise, the value of the right-hand
operand is converted to the type of
the left-hand variable, is subjected
to value set conversion (§5.1.13) to
the appropriate standard value set
(not an extended-exponent value set),
and the result of the conversion is
stored into the variable.
Then from section 17.4.5:
Two actions can be ordered by a happens-before relationship. If one action happens-before another, then the first is visible to and ordered before the second.
If we have two actions x and y, we write hb(x, y) to indicate that x happens-before y.
- If x and y are actions of the same thread and x comes before y in program order, then hb(x, y).
- There is a happens-before edge from the end of a constructor of an object to the start of a finalizer (§12.6) for that object.
- If an action x synchronizes-with a following action y, then we also have hb(x, y).
- If hb(x, y) and hb(y, z), then hb(x, z).
It should be noted that the presence of a happens-before relationship between two
actions does not necessarily imply that they have to take place in that order in an
implementation. If the reordering produces results consistent with a legal execution,
it is not illegal.
In other words, it's okay for weird stuff to happen even within a single thread but that mustn't be observable. In this case the difference would be observable, which is why I believe it would be illegal.