|
All About the Singleton Design Pattern
by Sridhar M S
There are various problems that every developer encounters during the development phase of almost every project. These various problems are so common that all-purpose solutions have been developed for them—called "Design Patterns." A design pattern is a widely accepted solution to a recurring problem. They provide a blue-print/pseudo code to follow when implementing part of the program that will be written to solve the problem. They do not recommend or follow any specific algorithms for implementation.
The pattern for discussion here is the "Singleton" pattern. Here, the class actually distributes the only instance of itself. The singleton pattern is designed to restrict instantiation of a class to one. This is useful when you require exactly one object to coordinate actions across the application.
Usually, it's desirable to have a single instance of a class—it gives you a common entry point and requires the same data across an application. For example, suppose you've got a print activity in a system. You've made it accessible globally from any part of the application, ensuring appropriate usage, and always with a single point from which to proceed.
Implementing the concept of singleton for the print activity will ensure that you always have only one instance of the print activity class and there shall be a global point access to this object. Creating only one instance of the object, irrespective of the number of times you instantiate and use it, also saves a lot of memory—especially when the object is relatively large in size. In order to write a singleton class, you'll need to understand the following:
- Creating a static variable of the instance of your singleton class will ensure that there are no two instances created at any given point.
- Exposing a method named
getInstance() will return the instance of the class— either by creating it or returning the instance if it already exists.
public class SingletonClass {
private static SingletonClass singletonClass = null;
private ClassicSingleton() {
// No one can instantiate.
}
//public method that will be invoked from other classes.
public static ClassicSingleton getInstance() {
if(singletonClass == null) {
singletonClass = new ClassicSingleton();
}
return singletonClass;
}
}
The above code also implements the concept of lazy initialization—meaning, you're creating the object of the singleton class, only when the getInstance() method is invoked. It also means that if the getInstance() method is not invoked, then the instance shall never be created.
There's only one small problem: this code is not thread safe. Assuming there are two or more threads, acting on the same class, trying to get an instance of the SingletonClass and that they do so in the order in which they are created, there will be no problems. They'll both acquire the same instance of the class. But that's an awful lot to assume.
However, if the first thread is already in the process of obtaining the instance and it gets interrupted, both first and second threads will obtain instances—thereby defeating the entire singleton concept. The interruption could be a small delay for the first thread, like sleep.
New on the Java Boutique:
New Review:
Time Management Made Easy with the Quartz Enterprise Job Scheduler
Why not just use the Java timer API? This open source scheduling
API boasts simplicity, ease-of-integration, a well-rounded feature
set, and it's free!
New Applet:
Reverse Complement
Reverse Complement is a simple applet that converts DNA or RNA
sequences into three useful formats.
Elsewhere on internet.com:
WebDeveloper Java
Lots of Java information on webdeveloper.com
WDVL Java
Thorough Java resource at the Web Developer's Virtual Library.
ScriptSearch Java
Hundreds of free Java code files to download.
jGuru: Your View of the Java Universe
Customizable portal with online training, FAQs, regular news updates, and tutorials.
| 
