Re: Singleton Pattern
On 8/16/2011 12:09 AM, Peter Duniho wrote:
On 8/15/11 10:07 PM, Patricia Shanahan wrote:
On 8/15/2011 7:56 AM, Lew wrote:
Final fields, especially immutable ones, make a lot of useful
guarantees, and you don't have the field in the first place unless
it's going to be used at some point anyway. Just freaking initialize
Different program runs do different things, so there can be fields that
are used some runs but not others. That is especially the case for
library classes that may be used in many different programs.
However, the initializer for a static field executes during class
initialization. How often does a singleton class get initialized without
its getInstance method ever being called?
What does the Java specification say?
The Java specification says:
"Before a class is initialized, its direct superclass must be
initialized, but interfaces implemented by the class need not be
initialized. Similarly, the superinterfaces of an interface need not be
initialized before the interface is initialized.
A class or interface type T will be initialized immediately before the
first occurrence of any one of the following:
* T is a class and an instance of T is created.
* T is a class and a static method declared by T is invoked.
* A static field declared by T is assigned.
* A static field declared by T is used and the field is not a constant
* T is a top-level class, and an assert statement (??14.10) lexically
nested within T is executed.
Invocation of certain reflective methods in class Class and in package
java.lang.reflect also causes class or interface initialization. A class
or interface will not be initialized under any other circumstance."
In C#, the run-time is permitted to, and in fact does, delay class
initialization until the class is actually accessed. I'd just always
assumed Java took advantage of the same optimizations.
I read the last sentence as being a bit stronger than that. The JVM is
required to delay class initialization until it is needed. Of course,
the singleton could have another static method that gets called in a
significant number of program runs that never call the getInstance
method. If it does, it might be simpler and cleaner to refactor to
change that in preference to jumping through hoops to avoid creating the
instance during class initialization.