Implementation of singleton mode

• Definition
  This type of design pattern is a creation pattern , It provides the best way to create objects .
  This pattern involves a single class , This class is responsible for creating its own objects , Also make sure that only a single object is created . This class provides a way to access its unique objects , You can directly access , There is no need to instantiate an object of this class .
• Realization

public  class Singleton{
    
	// A private waiting variable holds an instance of the class , Not directly accessible and modifiable 
	private static Singleton instance= new Singleton();
	// Privatization constructor , Cannot be used by external bars to create instances 
	private Singleton(){
    }
	// The only interface gets the object of the singleton 
	public static Singleton getInstance(){
    
		return instance;
	}
	/** * Other members of the class  **/



}

First, the constructor is controlled as private , Can only be instantiated for calls within a class , In this way, other classes cannot instantiate the object .
secondly , Define a variable that holds a unique instance , Must be a class variable , Used to save unique instance objects .
Next, provide an interface to get the unique instance .
Such as ,static Decorated class variables instance In the initialization phase of class loading, you will get an instance , Keep in method area , Execute the only instance object in the heap , Because it is directly saved in the method area , It also provides a static method access method, so each time you access the instance of this class, you will get the class variables that save the method area instance value , This value points to an object in the heap , Class variables instance Value value is unique （ Because classes are unique in the method area ） So the instance is also unique .
The above method is thread safe , But as long as the class is loaded, an object will be created regardless of whether it is used or not , Waste of space is not supported Lazy initialization , So there is support Lazy Implementation method of initialization .
——————————————————————————————————————————————

public  class Singleton{
    
	// A private waiting variable holds an instance of the class , Not directly accessible and modifiable 
	private volatile static Singleton instance;
	// Privatization constructor , Cannot be used by external bars to create instances 
	private Singleton(){
    }
	// The only interface gets the object of the singleton 
	public static Singleton getInstance(){
    
	    // If it does not exist during use, it will be initialized first , Because to ensure that only one object is created , Apply synchronization lock 
		if(instance = null){
    
			synchronized(Singleton.class){
    
				if(instance = null)
				instance = new Singleton;
			}
		}
		return instance;
	}
	/** * Other members of the class  **/



}

This implementation method instantiates the class only when the object needs to be obtained , It is realized. Lazy initialization , For thread safety, that is, no matter how many threads access at the same time, only one object can be instantiated, and a synchronization lock is required , The class variables of the instance object need to use volatile Decoration ensures that other threads are visible after one thread is instantiated .
Although this method has realized Lazy Initialization, but adding a synchronization lock will affect some performance , You can't have both fish and bear

————————————————————————————————————————
Another common implementation is , By creating inner classes , The inner class is loaded only when it is used , That is, by delaying the loading of classes Lazy The function of initialization , It is thread safe again

public class Singleton {
      
    private static class SingletonHolder {
      
    private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){
    }  
    public static final Singleton getInstance() {
      
    return SingletonHolder.INSTANCE;  
    }  
}