Singleton mode instance

The singleton pattern

• The singleton pattern （Singleton Pattern） yes Java One of the simplest design patterns in . 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 .

Aspects of singleton pattern instances that need attention

1. There is only one instance of a class
   1. Constructor privatization
   2. You have to create your own instance
      1. Contains a static variable of this class to hold this unique instance
   3. Provide examples to the whole system by itself
2. Provide external access to the instance object
   1. Direct exposure
   2. With static variables get Method to get

Classification of singleton patterns and several common forms

Hungry Chinese style : Create objects directly , There is no thread safety issue

1. Directly instantiate the starved Chinese style ( Simple and intuitive )

   /* *  Hungry Chinese style : *  Create instance objects directly , Whether or not it is necessary to , Will create  * * (1)  Constructor privatization  * (2)  Create your own , And save... With static variables  * (3)  Provide instances to the outside  * (4)  Emphasize that this is a single case  */
   public class SingLeton1 {
         
   	public static final SingLeton1 INSTANCE = new SingLeton1();
   	private SingLeton1() {
         
   		
   	}
   }		
   

2. Enumeration ( Most succinct )

   	/* *  Enumeration type : Indicates that the type is limited  *  We can limit it to one , Just a single case  */
   public enum Singleton2 {
         
   	INSTANCE 
   }
   

3. Static code block hungry han ( Suitable for complex instantiation )

   	/* *  This method is usually used to load initialization data , Or load the data in the configuration file  * * */
   	public class Singleton3 {
         
   	public static final Singleton3 INSTANCE;
   	private String info;
   	
   	static{
         
   		try {
         
   			Properties pro = new Properties();
   			
   			pro.load(Singleton3.class.getClassLoader().getResourceAsStream("single.properties"));
   			
   			INSTANCE = new Singleton3(pro.getProperty("info"));
   		} catch (IOException e) {
         
   			throw new RuntimeException(e);
   		}
   	}
   	
   	private Singleton3(String info){
         
   		this.info = info;
   	}
   
   	public String getInfo() {
         
   		return info;
   	}
   
   	public void setInfo(String info) {
         
   		this.info = info;
   	}
   
   	@Override
   	public String toString() {
         
   		return "Singleton3 [info=" + info + "]";
   	}
   	
   }
   
   

Slacker type : Delay creating objects

1. Thread unsafe ( For single thread )

   	/* *  Slacker type :  Delay creating this instance object  * (1) Constructor privatization  * (2)  Use static variables to save unique instances  * (3)  Provide static methods , Get this instance object  */
   public class Singleton4 {
         
   	private static Singleton4 instance;
   	private Singleton4() {
         
   		
   	}
   	public static Singleton4 getInstance() {
         
   				if(instance == null) {
         
   					instance = new Singleton4();
   				}
   		return instance;
   	}
   }
   

2. Thread safety ( For multithreading )

   	public class Singleton4 {
         
   	private static Singleton4 instance;
   	private Singleton4() {
         
   		
   	}
   	public static Singleton4 getInstance() {
         
   		if(instance == null) {
         
   			synchronized (Singleton4.class) {
         
   				if(instance == null) {
         
   					try {
         
   						Thread.sleep(1000);
   					} catch (Exception e) {
         
   						e.printStackTrace();
   					}
   					instance = new Singleton4();
   				}
   				
   			}
   		}
   		
   		return instance;
   	}
   }
   
   

3. Static inner class form ( For multithreading )

   	/* *  When the inner class is loaded and initialized , To create INSTANCE Instance object  *  Static inner classes do not automatically initialize with the loading and initialization of outer classes , It is to be loaded and initialized separately . *  Because when the inner class is loaded and initialized , Created , So it's thread safe  */
   public class Singleton6 {
         
   	private Singleton6(){
         
   		
   	}
   	private static class Inner{
         
   		private static final Singleton6 INSTANCE = new Singleton6();
   	}
   	
   	public static Singleton6 getInstance(){
         
   		return Inner.INSTANCE;
   	}
   }