How to Use Singleton Design Pattern In Java

Singleton is the simplest design pattern which has categorized under creational design patterns.Most significant difference of the Singleton design pattern is allowing application to create only one instance from start to the end of the application.Singleton manage a global instance that can be access by other instances.

Assume we have a system that can manage online users.In there, system is  counting user login events and user logout events.This is like a log file.The whole system needs only one log file and it is maintaining accurate user count.

Here a sample class file created for above scenario.Refer this code and try to understand the behavior of singleton pattern.
--source code can be not loaded because of  network issues--

	class Singleton {
	private static Singleton instance=null;
	int online_usercount;
	private Singleton(){
	online_usercount=0;
	/*As this constructor private Singleton do not support inheritance.*/
	}
	public static Singleton getInstance(){
	if(instance==null){
	instance=new Singleton();
	}
	return instance;
	}
	public void userLogin(){
	online_usercount++;
	}
	public void userLogout(){
	online_usercount--;
	}
	public int getOnlineUserCount(){
	return online_usercount;
	}
	}
	public class Onlineuser {
	public static void main(String args[]){
	Singleton s1=Singleton.getInstance();
	//Initializing s1 objects || We can directly call 'getInstance()' because it is static method. || Now online_usercount=0
	Singleton s2=Singleton.getInstance();
	s1.userLogin(); //online_usercount=1
	s1.userLogin(); //online_usercount=2
	s1.userLogout(); //online_usercount=1
	s1.userLogin(); //online_usercount=2
	s2.userLogin();
	System.out.println("s1 online user count :"+s1.getOnlineUserCount());
	System.out.println("s2 online user count :"+s2.getOnlineUserCount());
	if(s1.equals(s2)){
	System.out.println("****Singleton Design Pattern Is Working****");
	}
	}
	}

view raw Onlineuser.java hosted with ❤ by GitHub

Output :

output

Some of disadvantages of Singleton Design Pattern

1. Do not allow inheritance.

2. In a garbage collected environment singletons can quickly become an issue with regard to memory management.

3. Singletons are also a problem from a testing perspective. They tend to make isolated unit-tests difficult to write.

4. You can not rely that there is exactly one instance of a singleton in your application - especially when it comes to clustering

5. There is also the multi-threaded scenario where singletons can become a issue as well as a synchronization issue.

Do more coding.Explore innovations.