| Wiki Markup |
|---|
The singleton design pattern's intent is succinctly described by the seminal work of Gamma et al. \[[Gamma 95|AA. Java References#Gamma 95]\]: |
Ensure a class only has one instance, and provide a global point of access to it.
| Wiki Markup |
|---|
"Since there is only one Singleton instance, any instance fields of a Singleton will occur only once per class, just like {{static}} fields. Singletons often control access to resources such as database connections or sockets." |
\[[Fox 01|AA. Java References#Fox 01]\]. Other applications of singletons involve maintaining performance statistics, system monitoring and logging, implementing printer spoolers or as simple as ensuring that only one audio file plays at a time. |
A typical implementation of the Singleton pattern in Java is the creation of a single instance of the Singleton class that encloses a private static instance field.
The instance can be created using lazy initialization, which means that the instance is not created when the class loads but when it is first used.
...
When the getter method is called by two (or more) threads or classes simultaneously, multiple instances of the Singleton class might result if one neglects to synchronize accessaccess is not synchronized.
| Code Block | ||
|---|---|---|
| ||
class MySingleton {
private static MySingleton _instance;
private MySingleton() {
// construct object
// private constructor prevents instantiation by outside callers
}
// lazy initialization
// error, no synchronization on method access
public static MySingleton getInstance() {
if (_instance == null) {
_instance = new MySingleton();
}
return _instance;
}
// Remainder of class definition
}
|
...
Multiple instances can be created even if you add a synchronized(this) block is added to the constructor call.
| Code Block | ||
|---|---|---|
| ||
// Also an error, synchronization does not prevent
// two calls of constructor.
public static MySingleton getInstance() {
if (_instance == null) {
synchronized (MySingleton.class) {
_instance = new MySingleton();
}
}
return _instance;
}
|
...
To avoid these issues, make getInstance() a synchronized method.
| Code Block | ||
|---|---|---|
| ||
class MySingleton {
private static MySingleton _instance;
private MySingleton() {
// construct object
// private constructor prevents instantiation by outside callers
}
// lazy initialization
public static synchronized MySingleton getInstance() {
if (_instance == null) {
_instance = new MySingleton();
}
return _instance;
}
// Remainder of class definition
}
|
Applying a static modifier to the getInstance() method (which returns the Singleton) allows the method to be accessed subsequently (after the initial call) without creating a new object.
...
| Code Block | ||
|---|---|---|
| ||
private Object readResolve() {
return _instance;
}
|
| Wiki Markup |
|---|
Bloch \[[Bloch 08|AA. Java References#Bloch 08]\] suggests the use of an {{enum}} type as a replacement for traditional implementations (shown below). Functionally, this approach is equivalent to commonplace implementations. It ensures that only one instance of the object exists at any instant and also provides the serialization property sinceas {{java.lang.Enum<E>}} extends {{Serializable}}. |
...
| Wiki Markup |
|---|
This compliant solution takes into account the garbage collection issue described above. A class is not garbage collected until the {{ClassLoader}} object used to load it itself becomes eligible for garbage collection. An easier scheme to prevent the garbage collection is to ensure that there is a direct or indirect reference from a live thread to the singleton object that needs to be preserved, from a live thread. This compliant solution demonstrates this method (adopted from \[[Patterns 02|AA. Java References#Patterns 02]\]). |
| Code Block | ||
|---|---|---|
| ||
public class ObjectPreserver implements Runnable {
private static ObjectPreserver lifeLine = new ObjectPreserver();
// Neither this class, nor HashSet will be garbage collected.
// References from HashSet to other objects will also exhibit this property
private static HashSet protectedSet = new HashSet();
private ObjectPreserver() {
new Thread(this).start(); // keeps the reference alive
}
public synchronized void run(){
try {
wait();
}
catch(InterruptedException e) { e.printStackTrace(); }
}
// Objects passed to this method will be preserved until
// the unpreserveObject method is called
public static void preserveObject(Object o) {
protectedSet.add(o);
}
// Unprotect the objects so that they can be garbage collected
public static void unpreserveObject(Object o) {
protectedSet.remove(o);
}
}
|
...
Using lazy initialization in a Singleton without synchronizing the getInstance() method may lead to creation of multiple instances and can as a result, violate the expected contract.
...