Singleton Pattern

Singleton pattern is to make sure only 1 instance is created through entire project, it's applicable when object creation is complicated but 1 instance is enough, like tool class, property object or session, it can help avoid space waste.

In total there are 8 ways to implement it, 3 ways are recommanded.

Way1:

Hungry loading mode, it's only applicable for single thread and always create and only create one instance, even the entire project doesn't request to create any.

private Singleton(){}
private final static Singleton instance = new Singleton();
public static Singleton getInstance(){
    return instance;
}

Way2: (recommanded)

Lazy loading mode, double comparation way. Applicable for multithreading and safe. Mention key word "volatile" because create new instance part is not atomic operation, actually in operation system, it will be completed in 3 steps,

1. Create new memory space
2. Create new object instance
3. New object instance points to new created space

However if there's 2 threads comes to this part, thread A is using 132 steps (it may happen) to create new object instance and it's running at step3 now, at same time thread B comes to this part and program will tell thread B new instance is created and return it to thread B, but because step2 is not completed, thus, thread B will get a empty space. Add "volatile" key word, we can avoid to face this issue.

But this way can be destoyed by reflection mechanism, it's only performed on purpose, normally no need to consider on it.

private Singleton(){}
private static volatile Singleton instance;
public static Singleton getInstance(){
    if (instance == null){
        synchronized (Singleton.class){
        if (instance == null){
            instance = new Singleton();
           }
        }
    }
    return instance;
}

Way3: (recommanded)

Enum class

Like enum class to return data dictionary, singleton instance has only one status hence always return same object.

The only weekness is it's hungry loading mode, program always contains one instance.

enum Singleton{
    INSTANCE;
}