Re: Singleton Pattern
Eric Sosman wrote:
vbha...@gmail.com wrote:
People have been coming up with creative solutions to lazily implement
the singleton pattern in a thread-safe way. We have seen things like
double-checked locking
Which, as you know, is broken. As it happens, it's broken in pretty much e=
xactly the same way as your proposal.
This is one of the most well-discussed idioms in the literature. The flaws=
and solutions are pretty much out there for anyone to google.
Bear in mind that lazy initialization should be done judiciously, if at all=
.. See Joshua Bloch's /Effective Java/, Item 71, for example.
<http://java.sun.com/docs/books/effective/>
The Singleton (anti)pattern is also heavily abused.
and creating instance via a single-elemnt enum type.
I have thought of yet another [sic] way to implement this in a lazy and
thread-safe way. I haven't seen this proposed anywhere and it seems to
work unless I am missing something. Here it goes:
public class Singleton {
private static Singleton _instance;
private Singleton(){}
private synchronized static void createInstance(){
_instance = new Singleton();
}
public static Singleton getInstance(){
if (_instance == null){
createInstance();
}
return _instance;
}
}
The synchronized createInstance() method would eliminate the need to
do double-checked locking and the synchronization would happen only
when multiple threads call getInstance() before _instance has been
instantiated.
Anyone see any issues with this?
Yes.
T1: if (_instance == null)
"Aha! It's null! Let's go make one."
** context switch **
T2: if (_instance == null)
"Aha! It's null! Let's go make one."
T2: _instance = createInstance(); // instance #1
** context switch **
T1: _instance = createInstance(); // instance #2
... and the two threads go merrily on their way with references
to two different Singleton instances. With N threads, you could
get as many as N distinct instances.
See Doug Lea's and Brian Goetz's articles and books on Java threading, as w=
ell as the Java Language Specification. IBM Developerworks (Java) is a goo=
d online resource for articles. I recommend in particular /Java Concurrenc=
y in Practice/ by Goetz, et al., and many people urge /Concurrent Programmi=
ng in Java/ by Mr. Lea. The aforementioned /Effective Java/ has several ef=
fective tips on the subject as well.
Concurrent programming is subtle and quick to anger. It pays to study the =
literature thoroughly.
--
Lew