Offer2-Singleton prove safety mode

topic

Design a class, we can only generate an instance of the class

Singleton

Definitions: " a class is only one example , and to instantiate provided to the entire system."

"Ensure that only one instance of a class, and provide a global access point to access it ."

By definition, we can draw in a single embodiment mode, in that regard, we note that:

1. Examples of generated code can only be executed once, in order to ensure a unique instance of the class generated. At the same time the constructor should be set to private, and thus against others create an instance (so if the constructor method of privatization, external calls can not be instantiated class through new, so the first class should be the object instantiation).

2. The definitions and examples of a static static, the instance is created if necessary.

　　1) static method can call the same kind of static member, but can not call non-static member directly. Because the static member class is loaded at the time of loading, that had been written before the object is to create a memory.

　　2) When you call a non-static member, you need to access by creating objects of that class.

　　3) ordinary members of the method (non-static method), you can directly access the non-static and static variables of the same kind.

　　4) Static methods belong to the class itself, and only static objects, but not belonging to an object class.

　　5) static method can use very frequently when applications can improve system performance.

　　6) may be used to define the attributes of the object will not change

3.final keywords. Modification of references, methods and classes

　　1) Modified class: This class is final class can not be inherited

　　2) modification of the method: the ultimate method can not be overridden by subclasses, but can be inherited

　　3) modification of references: must be initialized, and can not be modified. If the reference is a reference data type, the value of the address references can not be modified, but the content of the object inside the reference points may be modified.

4.JVM internal mechanism to ensure that when a class is loaded, the loading process of this class is the thread mutually exclusive.

solution

1. there is a method thread safety issues. If thread A execution to the new method, which is the object has not created, the emergence of a thread B to perform determined sin == null, the condition is true, it will enter into a partially created instance. Two examples of memory will appear.

public class Singleton1{
  private static Singleton1 sin=null;
  private Singleton1()
    {}                  
  public static Singleton1 getSingleton1(){
        if(sin==null){
                sin=new Singleton1();
        }
        return sin;    
    }  
}

2. In order to solve the above problem, since only one thread at a time to obtain synchronization lock, we can choose to add the synchronized keyword on a method to get the singleton object, but the lock is very time consuming. . It will lead to efficiency too poor, as if the first thread holding the lock, then the lock is released after instantiation, then the second thread will be locked, even after the judge instance has been created, can not be instantiated. That went to the back of the thread concurrency locked here, get every instance, will try to add a synchronization lock.

public class Singleton2{
  private static Singleton2 sin=null;
  private Singleton2()
    {}                  
  public static synchronized Singleton2 getSingleton2(){
        if(sin==null){
                sin=new Singleton2();
        }
        return sin;    
    }  
}

3. To solve this problem, we can not lock on method, and in the internal locking methods. So much better time efficiency.

public  class Singleton3 {
   Private  static Singleton3 SiN = null ;
   Private Singleton3 () 
    {}                   
  public  static Singleton3 getSingleton3 () {
         IF (SiN == null ) {// If the determination is not empty, then that object has been created over, returned directly to the object, it will not come sync locked, do not waste unnecessary resources. Which does not affect the performance of 
       　　　　 the synchronized (Singleton3. Class ) {
　　　　　　　　　　　　IF (SiN == null ) {// If a determination is empty, then there will be many threads to create the object through the first layer determination. So even if a thread executing the second layer, releasing the lock, or there will be other thread synchronization lock into this one. To prevent multiple created, so an additional layer of judgment. 
                　　　　　　SiN = new new Singleton3 ();  
　　　　　　　　　　　　}
　　　　　　　　} 
        }
        return sin;    
    }  
}

4. not lazy loading, but when the class is created, put the corresponding instance created. But if you need a pass parameters when acquiring an object, you can not use this method & initialized when the class is loaded, the object will be prone to garbage, waste of memory. (Hungry Chinese-style)

public  class Singleton4 { 
  // create an object of Singleton4
   Private  static Singleton4 SiN = new new Singleton4 (); 
  // constructor to allow private, so that the class is not instantiated
   Private Singleton4 () 
    {}                   
  // Get the only available objects
   public  static Singleton4 getSingleton4 () {
         return SiN;     
    }   
}

The static inner class, delay the initialization of the static field use. Use classloader mechanisms to ensure that only one thread at initialization instance. Due SingletonHolder class is not actively used, only by an explicit call getInstance () method, it will explicitly load SingletonHolder class to instantiate INSTANCE.

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

6. enumeration. Enumerable object is born singleton, clients are not allowed to create an instance of the enumeration class can not be extended. Privatization does not solve the insurance structure, sequence of questions.

public  enum Singleton6 { 
　　// create an enumeration object natural single embodiment 
　　INSTANCE; 
　　// External exposure of the object's interface acquires a
　　public  Singleton6 the getInstance () { 
　　　　return INSTANCE; 
　　}         
}

Extended - design pattern (23 kinds)

1. Design mode according to the intent or purpose of classification, mainly covering three modes Category: Creator / structural / behavioral

2. Creator mode: provide a mechanism to create an object, existing code to increase flexibility and reusability

　　1) Factory Method mode : providing a parent class object to create interfaces that allow subclasses decide the type of object is instantiated, the client is not exposed to create a logical object is created.

　　2) the abstract factory pattern : to create a series of related objects without specifying their concrete classes. For each variant products, are factory interface to create different classes based on the abstract factory, each plant type can only return to a particular category of products.

　　Does not modify the original factory code, can be directly extended, do not care about the details of construction and complex process object instance, and Comparative example process configuration

　　3) generator mode: an object configuration codes abstracted from the product category, and in a separate object called the generator.

　　4) prototype model: you can replicate an existing object, but the code is not necessary to rely on the class to which they belong. The cloning procedure prototype pattern assigned to the actual object to be cloned, the clone mode all supported object declaration a common interface, the interface is used to clone, without the need to code and the object belongs to the class coupling.