What is the singleton mode?

In Single Pattern, only one instance of an object can be represented by a singleton. The singleton pattern is implemented in such a way that a class can only return a reference to an object and a method that gets the unique instance (this method must be a static method).

Why use the singleton design pattern?

Through the singleton mode, you can ensure that there is only one instance in the system, thus saving or controlling system resources in certain specific situations.

Single case pattern classification and its code implementation

Hungry mode

Create an instance from the beginning. Although relatively simple and common. But one obvious drawback is that an instance is created whether or not the method that gets the instance is called.

public class Single {
    private static final Single single = new Single();
    private Single(){}
    public static Single getSingle(){
        return single;
    }
}

2. Lazy mode

He improved the inadequacies of the above "hungry mode" and calledgetSingle() The method first determines whether the instance is empty, creates an instance if it is empty, and creates it when the method is called.

public class Single {
    private static Single single;
    private Single(){}
    public static Single getSingle(){
        if (single == null){
            single =  new Single();
        }
        return single;
    }
}

3. Thread-safe lazy mode

Lazy modeThere are also problems. That is if there are multiple threads calling in parallelgetSingle() At the time of the method, multiple instances will still be created, and the single instance mode will be invalid. So set up thread synchronization on this basis (keysynchonized)。synchronizedThe role is to ensure that at most one thread is running at the same time, thus avoiding the problems caused by multi-threading.

public class Single {
    private static Single single;
    private Single(){}
    public static synchronized Single getSingle(){
        if (single == null){
            single =  new Single();
        }
        return single;
    }
}

4. Double test lock

The above solution is not perfect. Every callgetSingle()Thread synchronization is required, consider this situation,singleThe object has been created, it can be returned directly to the object, but it has to be synchronized.
So on this basis, there isDouble check lockMethods

public class Single {
    private volatile static Single single;
    private Single(){}
    public static Single getSingle(){
        if (single == null){
            synchronized (Single.class){
                if(single == null){
                    single = new Single();
                }
            }
        }
        return single;
    }
}

• note

Also need to add one to the instancevolatile The keyword, its role is to prevent the compiler to optimize the code itself, to ensure that the order of the code is fixed. This involvesJVMThe code optimization mechanism.

5. Static inner class

The above methods are constantly improving, a bit complicated, but they can passStatic inner classTo ensure thread safety.

public class Single {
    private static class SingleHoder{
        private static final Single single = new Single();
} 
    private Single(){}
    public static Single getSingle(){
        return SingleHoder.single;
    }
}

Single classIs private, exceptgetSingle() methodThere is no other way to access the instance, and the instance object will only be created when the method is called.

6. Enumeration

This method is the simplest. We can passSingle.INSANCETo access the instance and create an enumeration is thread-safe by default, and it also prevents problems caused by deserialization.

public enum  Single {
    INSTANCE;
    public void whateverMethod(){};
}

About the author

personal blog:http://yhch.xyz