Detailed single case mode

The singleton pattern

1. Hungry han singleton

characteristic : First, instantiate the object

Existing problems : It may cause a waste of resources and space

/** * @Description:  The hungrier singleton  * @Author: Boo, boo, boo, boo ~~~ * @Date:2022/6/29 */
public class Hungry {
    

    /** *  Suppose this class opens up a large array when it is created  * *  The problem with this starving singleton mode is that it may cause a waste of resource space  *  For example, this class will create many large arrays , So the singleton pattern is to instantiate the object  *  If this object is not used later, a lot of space will be wasted  *  Therefore, according to the problems of the hungry type, the lazy type singleton mode is introduced  */
    private byte[] data1 = new byte[1024 * 1024];
    private byte[] data2 = new byte[1024 * 1024];
    private byte[] data3 = new byte[1024 * 1024];
    private byte[] data4 = new byte[1024 * 1024];
    
    /** *  A private constructor  */
    private Hungry() {
    

    }
    /** *  Hungry han singleton , No matter three, seven, twenty-one , Load the object first  */
    private final static Hungry HUNGRY = new Hungry();
    
    public static Hungry getInstance() {
    
        return HUNGRY;
    }
    
}

2. An example of lazy style

//--------------------- Base version singleton mode , There are thread safety issues ----------------------
public class LazyMan {
    

    /** *  Private structure  */
    private LazyMan() {
    
        
    }

    /** *  Don't instantiate the object first  */
    private static LazyMan lazyMan;

    /** *  Check whether the following objects are empty , When it is empty, it is created  * @return */
    public static LazyMan getInstance() {
    
        if (lazyMan == null) {
    
            lazyMan = new LazyMan();
        }
        return lazyMan;
    }
}
//----------------------- Dual detection lock mode version -----------------------------
public class LazyMan {
    

    /** *  Private structure  */
    private LazyMan() {
    
        
    }

    /** *  The double detection lock object is given as volatile To embellish , Prevent command rearrangement , because : * lazyMan = new LazyMan();  This new The operation of objects is not atomic at the bottom  * 1.  Allocate memory space  * 2.  Execute construction , Initialize object  * 3.  Point this object to this space  *  Suppose now A The thread executes the code that creates the instance , Instruction rearrangement occurs at the bottom   The order of three steps to create an object is  1 3 2 *  It means threads A The object points to the space before it is initialized , Suppose there is a thread B So far  *  Threads B In judging the first lazyMan==null When it comes to false, Because the thread A Has pointed to memory space  *  So at this point, the thread B This object is returned directly , But actually threads A This object has not been initialized yet , So the object returned is nihilistic  *  So in order to rearrange instructions when creating objects , Add one more volatile Keyword modification  */
    private volatile static LazyMan lazyMan;

    /** *  Check whether the following objects are empty , When it is empty, it is created  * @return */
    public static LazyMan getInstance() {
    
        // This is the first one lazyMan == null  The function of is to improve efficiency , Without this layer , Get the lock every time , Getting a lock is actually a very efficient operation 
        if (lazyMan == null) {
    
            synchronized (LazyMan.class) {
    
                if (lazyMan == null) {
    
                    lazyMan = new LazyMan();
                }
            }
        }
        return lazyMan;
    }
}

3. Static inner class gets the singleton

public class Holder {
    
    /** *  Constructor private  */
    private Holder() {
    

    }

    public static Holder getInstance() {
    
        return InnerClass.HOLDER;
    }
    /** *  Create instances of static inner classes  */
    public static class InnerClass{
    
        private static final Holder HOLDER = new Holder();
    }
}

4. Reflection breaking singleton mode

Normal acquisition

    public static void main(String[] args) {
    
        LazyMan instance1 = LazyMan.getInstance();
        LazyMan instance2 = LazyMan.getInstance();
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }

Broken ring one : A single instance is obtained in the normal way , A single instance is obtained by reflection

    public static void main(String[] args) throws Exception {
    
        LazyMan instance1 = LazyMan.getInstance();
        // Get constructor of singleton class 
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        // Ignore private constructors 
        declaredConstructor.setAccessible(true);
        // Get instances through reflection 
        LazyMan instance2 = declaredConstructor.newInstance();
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }

• resolvent , Improve private constructors , The way of triple detection lock , Let's judge from the construction method of the singleton class ,instance1 Is it empty , If it is not empty, an exception is thrown

    /** *  Private structure  */
    private LazyMan() {
    
        synchronized (LazyMan.class) {
    
            if (lazyMan != null) {
    
                // The constructor is also called if it is not empty , It means that it is destroyed by reflection , Throw an exception to prevent 
               throw new RuntimeException(" Do not attempt to use the reflection breaking singleton mode !!!");
            }
        }
    }

Broken ring II , Create objects without using the references provided in the class , Every time you create an object, you use the reflection method

    public static void main(String[] args) throws Exception {
    
        // Get constructor of singleton class 
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        // Ignore private constructors 
        declaredConstructor.setAccessible(true);
        // Get instances through reflection 
        LazyMan instance1 = declaredConstructor.newInstance();
        LazyMan instance2 = declaredConstructor.newInstance();
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }

• The solution to this situation , It can be solved by making a mark

    /** *  Traffic light strategy , Prevent single case cup damage  */
    private static boolean target = false;

    /** *  Private structure  */
    private LazyMan() {
    
        if (!target) {
    
            target = true;
        } else {
    
            throw new RuntimeException(" Don't try to break the loop by reflection ");
        }
    }

Broken ring three , By breaking the fields in the class , Destroy the traffic light strategy

    public static void main(String[] args) throws Exception {
    
        // Get constructor of singleton class 
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        // Ignore private constructors 
        declaredConstructor.setAccessible(true);
        // Get... In the singleton class target Field 
        Field target = LazyMan.class.getDeclaredField("target");
        target.setAccessible(true);
        // Get instances through reflection 
        LazyMan instance1 = declaredConstructor.newInstance();

        // After execution , We change the value of the field to false
        target.set(instance1,false);

        LazyMan instance2 = declaredConstructor.newInstance();
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }

The law is strong !!!

5. The way to enumerate , Prevent single cases from being destroyed

/** * @Description:  Enumeration prevents the singleton from being destroyed  * enum It's also a class  * @Author: Boo, boo, boo, boo ~~~ * @Date:2022/6/30 */
public enum EnumSingle {
    
    INSTANCE;
    public EnumSingle getInstance() {
    
        return INSTANCE;
    }


}
class Test {
    
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    
        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();

        System.out.println(instance1);
        System.out.println(instance2);
    }
}

• The final decompiled enumeration type is a parameterized constructor
• Reflection violation enumeration throws an exception