Goal: to have single object as long as app exists
How to achieve that:
Step 1: have a private constructor of the class
This
helps, you can’t create object of the class from outside
Class singleton{
Private singleton(){
}
}
Ok, then How to create an object
Step 2: Have a static
public function
Responsibility
of this function is to create an object
Why public scope :
So that, this function can be called from outside
Why static : this function can be called without
creating object of it .
Class singleton{
Private static singleton singletonObj;
Private singleton(){
}
Public static singleton getInstance(){
If(null == singletonObj )
singletonObj = new singleton();
return singletonObj;
}
}
We have now created singletonObj as single instance.
Is my job over
? this implementation is good as long
as you are working with single threaded application. But, the modern applications are using
multithreaded.
Step 3: Use
synchronized block
Public static singleton getInstance(){
Synchronized(singleton.class) {
If(null == singletonObj )
singletonObj = new singleton();
}
return singletonObj;
}
Well, we have achieved it.
Now, Assume singletonObj created, Thread t1 and t2
going to call this method to get the singletonObj.
Thread t1 calling
this method, as soon as it enters in to the function, lock is acquired because
of the synchronized block. And t1 is not exiting this function.
Now , t2 calling
this method , as already lock is held by Thread t1, Thread t2 will wait to
release the lock.
This is
performance issue .
Step 4 : Add null
check
Public static singleton getInstance(){
If(null == singletonObj ) {
Synchronized(singleton.class) {
If(null == singletonObj )
singletonObj = new singleton();
}
}
return singletonObj;
}
If object is created, then it will call the return method directly.
Another optimization technique is, Using different lock
Class singleton{
Private static singleton singletonObj;
Private Object lockObj = new Object();
Private singleton(){
}
Public static singleton getInstance(){
If(null == singletonObj ) {
Synchronized(lockObj) {
If(null == singletonObj )
singletonObj = new singleton();
}
}
return singletonObj;
}
}
In case you have different function holding singleton class
lock, then without any problem you can access this function.
But still the
previous implementation holds good, because synchronized function gets executed
only once (ie till creation of the object ) whereas in new implementation we
have created object, that will be alive till the app exists.
