单例模式的4种写法，你知道吗？

1. 懒汉式

/**
 * 懒汉式
 *
 * @author by miao
 * @date 2020/11/9 11:46
 */
public class SingletonOne {

    private static SingletonOne instance;

    /**
     * 私有化类的构造器，让外部无法调用
     */
    private SingletonOne() {
    }

    public static SingletonOne getInstance() {

        if (instance == null) {

            instance = new SingletonOne();
        }

        return instance;
    }

}

1.2懒汉式优化

/**
 * 懒汉式优化
 *
 * @author by miao
 * @date 2020/11/10 9:37
 */
public class SingletonOneOPT {

    private static SingletonOneOPT instance;

    /**
     * 私有化类的构造器，让外部无法调用
     */
    private SingletonOneOPT() {
    }

    public static synchronized SingletonOneOPT getInstance() {

        if (instance == null) {
            
                instance = new SingletonOneOPT();
        }

        return instance;
    }
}

2.饿汉式

/**
 * 饿汉式
 *
 * @author by miao
 * @date 2020/11/10 9:40
 */
public class SingletonTwo {

    public static SingletonTwo instance = new SingletonTwo();

    /**
     * 私有化类的构造器，让外部无法调用
     */
    private SingletonTwo() {
    }

    public static SingletonTwo getInstance() {


        return instance;
    }
}

3.枚举

/**
 * @author by miao
 * @date 2020/11/10 11:01
 */
public enum  SingletonThree {
    
    SINGLETON,
    
    PROTOTYPE;
}

ps.枚举的天然特性保证了单例，天然的私有构造器，天然的线程安全性，未被大规模使用的原因是枚举出现的有点晚。

4.双重校验锁

/**
 * 双重校验锁demo
 *
 * @author miao
 */
public class SingletonDemo {

    /**
     * 防止指令重排
     */
    private static volatile SingletonDemo instance;

    private SingletonDemo() {
    }

    public static SingletonDemo getInstance() {

        if (instance == null) {

            synchronized (SingletonDemo.class) {

                if (instance == null) {

                    instance = new SingletonDemo();
                }
            }
        }

        return instance;
    }
}

注意：

1. volatile的使用，为了防止暴露一个未初始化的不完整单例实例；
2. 双重判空校验，第一个判断避免了频繁的加锁，第二个判断可以拦住多余的创建实例的线程；
3. 加锁，保证了线程安全（只有一个实例）