java improve the design patterns

This note is mainly taken from rookie tutorials, code re-implemented again, to facilitate their review. After we will continue to add other design patterns, to perfect, if you want to seriously study, you can go to the official website to learn rookie.

Singleton

1. lazy type, thread safe

Whether lazy initialization: Yes

Are multi-thread safe: No

Achieve Difficulty: Easy

Description: This is the most basic way of implementation, the biggest problem is not multi-threaded support, because it is not locked in the strict sense is not a singleton, this way lazyloading obviously, does not require thread safety.

public class Singleton {
    private static Singleton instance;
    private Singleton(){}
    
    public static Singleton getInstance(){
        if(instance==null){// 很多线程都会进来
            instance = new Singleton();
        }
        return instance;
    }
}

2. lazy type, thread-safe

Whether lazy initialization: Yes

Are multi-thread safe: Yes

Achieve Difficulty: Easy

Description: in this way have good lazyloading, able to work well in multi-thread, but inefficient.

Pros: The first call was initialized, to avoid wasting memory

Cons: Must be locked to ensure that a single case, but locking affect efficiency.

public class Singleton {
    private static Singleton instance;
    private Singleton(){}

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

3. starving formula

Whether lazy initialization: No

Are multi-thread safe: Yes

Achieve Difficulty: Easy

Description: This method is more common, but easy to produce garbage objects

Advantages: no lock, high efficiency

Disadvantages: initialized when the class is loaded, wasting memory

Based classloader mechanism to avoid synchronization of multiple threads, however, when the class loader instance to be instantiated,

public class Singleton {
  // 静态就已经new了
    private static Singleton instance = new Singleton();
    private Singleton(){}

    public static Singleton getInstance(){
        return instance;
    }
}

4. Double-checked locking / lock double check

DCL即double-checked locking

JDK Version: 1.5 after

Whether lazy initialization: Yes

Are multi-thread safe: Yes

Realize the difficulty: more complex

Description: double locking mechanism, safe and in a multi-threaded to ensure high performance

public class Singleton {
    private volatile static Singleton singleton;
    private Singleton(){}

    public static Singleton getInstance(){
      // 大部分情况下都不为空，直接返回，提高效率
        if(singleton==null){
            synchronized (Singleton.class){
              // 解决单例的判断
                if(singleton==null){
                    singleton=new Singleton();
                }
            }
        }
        return singleton;
    }
}

The register-based / static inner classes

Whether lazy initialization: Yes

Are multi-thread safe: Yes

Realize the difficulty: General

Description: This embodiment can achieve the same effects as a double lock object, but the implementation is simpler. Also use classloader mechanism to ensure that only one thread at initialization instance. Only by an explicit call getInstance method will explicitly load SingletonHolder class to instantiate instance. On the one hand instantiated instance consumption of resources, on the other hand, when you do not want to instantiate Singleton class loaders, because they can not take the initiative to ensure that Singleton class also possible to use so as to be loaded in other places, this time instantiation inappropriate.

public class Singleton {
  // 静态内部类，只有调用它的时候才会初始化
    private static class SingletonHolder{
        private static final Singleton INSTANCE = new Singleton();
    }
    private Singleton(){}
    public static final Singleton getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

6. Enumeration

JDK Version: 1.5 after

Whether lazy initialization: No

Are multi-thread safe: Yes

Achieve Difficulty: Easy

Description: This is the best way to implement the method of Singleton and more concise, automatic support serialization mechanism, absolutely prevent multiple instantiated

Because only joined after 1.5, less practical application

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

to sum up

Generally recommend the use of a third way a hungry man, only clear lazyloading, using a fifth static inner classes, involving the de-serialization, using the sixth enumeration method. There are other special needs, consider the fourth double check the lock mode.