Another Partial Solution
You might come to the conclusion that the only way to solve this problem is to use the synchronize keyword. But remember, using this keyword is at the cost of performance. Re-write the method getInstance() as follows:
public synchronized static SingletonClass getInstance() {
if(singleton == null) {
//This method shall include a sleep for the first thread only.
someSleepActivityForFirstThread();
//Creating a new instance of the singleton class
singletonClass = new SingletonClass();
}
return singletonClass;
}
Using the synchronize keyword in this way will be extremely costly, because it's acted upon every time the getInstance() method is invoked.
There's a different technique to avoid performance bottlenecks in applications, and this is to modify the code to synchronize only the assignment in the getInstance() method:
public static SingletonClass getInstance() {
if(singletonClass == null) {
synchronized(SingletonClass.class) {
singletonClass = new SingletonClass();
}
}
return singletonClass;
}
Notice that the synchronize keyword is not part of the method signature and is moved to a line within the method. This seems solve the problem.
But upon further analyzation, you'll see that the first thread that enters the synchronized block has been delayed for some reason and the second thread also enters the "if" block. After the first thread acquires the instance, the second thread will also obtain a new instance of the singleton class, which again violates the requirements.
Perhaps a null check for the singleton object within the synchronized block can provide a solution?
public static SingletonClass getInstance() {
if(singletonClass == null) {
synchronized(SingletonClass.class) {
if(singletonClass == null)
{
singletonClass = new SingletonClass();
}
}
}
return singletonClass;
}
This ensures that there is a double check made and solves the above, unforeseen problems. Having so many multiple null checks and synchronized keywords makes the code look complicated and confusing for a first time reader.
The Perfect Solution
Instead of trying to solve every issue individually, here's a technique you can use to resolve many issues at once. Here, you create the instance of the singleton class the first time the class is loaded onto memory. There is no lazy initialization and it ensures the class is available well in advance.
public class SingletonClass{
public final static SingletonClass singletonClass = new SingletonClass();
private SingletonClass() {
//Cannot be instantiated
}
}
This technique can be used in instances where you can create only one instance of a class—for instance, when you need to hold application level details such as constants, or registry details, etc. Using the singleton pattern in such cases may very well solve the many issues arising from incorrect data—especially if the data derives from multiple sources.
Related Resources
http://java.sun.com/developer/technicalArticles/
http://tomcat.apache.org/
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.
| 
