实现单例的几种方式

饿汉模式：

饿汉模式在类被初始化时就已经在内存中创建了对象,以空间换时间，故不存在线程安全问题。

package com.phy.java.singleton;

/**
 * @author ：mmzs
 * @date ：Created in 2020/4/12 12:11
 * @description：武汉模式不存在线程安全
 * @modified By：
 * @version: $
 */
public class HungrySingleton {
    // 立即加载方式==饿汉模式(空间换时间)
    private static HungrySingleton singleton = new HungrySingleton();

    private HungrySingleton() {
    }

    public static HungrySingleton getInstance() {
        // 此代码版本为立即加载
        // 此版本代码的缺点是不能有其它实例变量
        // 因为getInstance()方法没有同步
        // 所以有可能出现非线程安全问题
        return singleton;
    }
}

懒汉模式：

懒汉模式在方法被调用后才创建对象，以时间换空间，在多线程环境下存在风险。

package com.phy.java.singleton;

/**
 * @author ：mmzs
 * @date ：Created in 2020/4/12 11:51
 * @description：非线程安全的实现单例
 * @modified By：
 * @version: $
 */
public class NoSafetyLazySingleton {
    private static NoSafetyLazySingleton singleton;

    public NoSafetyLazySingleton() {
    }
    //getInstance()的返回值是一个对象的引用，并不是一个新的实例
    public static NoSafetyLazySingleton getInstance() {
        if (singleton == null) {
            singleton = new NoSafetyLazySingleton();
        }
        return singleton;
    }
}

package com.phy.java.singleton;

/**
 * @author ：mmzs
 * @date ：Created in 2020/4/12 11:57
 * @description：线程安全实现单例利用synchronized关键字，缺点是效率低
 * @modified By：
 * @version: $
 */
public class SafetyLazySingletonByKey {
    private static SafetyLazySingletonByKey instance;
    private SafetyLazySingletonByKey(){}
    //饿汉式利用synchronized 关键字实现单例模式
    public static synchronized SafetyLazySingletonByKey getInstance() {
        if (instance == null) {
            //懒加载模式（懒汉式）用的时候在加载
            instance = new SafetyLazySingletonByKey();
        }
        return instance;
    }
}

双重锁懒汉模式：

只有在对象需要被使用时才创建，第一次判断 INSTANCE == null为了避免非必要加锁，当第一次加载时才对实例进行加锁再实例化。这样既可以节约内存空间，又可以保证线程安全。但是，由于jvm存在乱序执行功能，DCL也会出现线程不安全的情况。

具体分析如下：

INSTANCE  = new SingleTon(); 

这个步骤，其实在jvm里面的执行分为三步：

• 1.在堆内存开辟内存空间。
• 2.在堆内存中实例化SingleTon里面的各个参数。
• 3.把对象指向堆内存空间。

由于jvm存在乱序执行功能，所以可能在2还没执行时就先执行了3，如果此时再被切换到线程B上，由于执行了第3步，INSTANCE 已经非空了，会被直接拿出来用，这样的话，就会出现异常。这个就是著名的DCL失效问题。

不过在JDK1.5之后，官方也发现了这个问题，故而具体化了volatile，即在JDK1.6及以后，只要定义为

private volatile static SingleTon  INSTANCE = null;

就可解决DCL失效问题。volatile确保INSTANCE每次均在主内存中读取，这样虽然会牺牲一点效率，但也无伤大雅。

public class DoubleCheckLockLazySingleton {
    private static volatile DoubleCheckLockLazySingleton INSTANCE = null;

    private DoubleCheckLockLazySingleton() {
    }

    public static DoubleCheckLockLazySingleton getInstance() {
        if (INSTANCE == null) {
            synchronized (DoubleCheckLockLazySingleton.class) {
                if (INSTANCE == null) {
                    INSTANCE = new DoubleCheckLockLazySingleton();
                }
            }
        }
        return INSTANCE;
    }
}

静态内部类模式

静态内部类的优点是：外部类加载时并不需要立即加载内部类，内部类不被加载则不去初始化INSTANCE，故而不占内存。即当SingleTon第一次被加载时，并不需要去加载SingleTonHoler，只有当getInstance()方法第一次被调用时，才会去初始化INSTANCE,第一次调用getInstance()方法会导致虚拟机加载SingleTonHoler类，这种方法不仅能确保线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。

那么，静态内部类又是如何实现线程安全的呢？首先，我们先了解下类的加载时机。

类加载时机：JAVA虚拟机在有且仅有的5种场景下会对类进行初始化。

• 1.遇到new、getstatic、setstatic或者invokestatic这4个字节码指令时，对应的java代码场景为：new一个关键字或者一个实例化对象时、读取或设置一个静态字段时(final修饰、已在编译期把结果放入常量池的除外)、调用一个类的静态方法时。
• 2.使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没进行初始化，需要先调用其初始化方法进行初始化。
• 3.当初始化一个类时，如果其父类还未进行初始化，会先触发其父类的初始化。
• 4.当虚拟机启动时，用户需要指定一个要执行的主类(包含main()方法的类)，虚拟机会先初始化这个类。
• 5.当使用JDK 1.7等动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化。

这5种情况被称为是类的主动引用，注意，这里《虚拟机规范》中使用的限定词是"有且仅有"，那么，除此之外的所有引用类都不会对类进行初始化，称为被动引用。静态内部类就属于被动引用的行列。

我们再回头看下getInstance()方法，调用的是SingleTonHoler.INSTANCE，取的是SingleTonHoler里的INSTANCE对象，跟上面那个DCL方法不同的是，getInstance()方法并没有多次去new对象，故不管多少个线程去调用getInstance()方法，取的都是同一个INSTANCE对象，而不用去重新创建。当getInstance()方法被调用时，SingleTonHoler才在SingleTon的运行时常量池里，把符号引用替换为直接引用，这时静态对象INSTANCE也真正被创建，然后再被getInstance()方法返回出去，这点同饿汉模式。那么INSTANCE在创建过程中又是如何保证线程安全的呢？在《深入理解JAVA虚拟机》中，有这么一句话:

虚拟机会保证一个类的clinit方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的clinit方法，其他线程都需要阻塞等待，直到活动线程执行clinit方法完毕。如果在一个类的clinit方法中有耗时很长的操作，就可能造成多个进程阻塞(需要注意的是，其他线程虽然会被阻塞，但如果执行clinit方法后，其他线程唤醒之后不会再次进入clinit方法。同一个加载器下，一个类型只会初始化一次。)，在实际应用中，这种阻塞往往是很隐蔽的。

故而，可以看出INSTANCE在创建过程中是线程安全的，所以说静态内部类形式的单例可保证线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。

那么，是不是可以说静态内部类单例就是最完美的单例模式了呢？其实不然，静态内部类也有着一个致命的缺点，就是传参的问题，由于是静态内部类的形式去创建单例的，故外部无法传递参数进去，例如Context这种参数，所以，我们创建单例时，可以在静态内部类与DCL模式里自己斟酌。

package com.phy.java.singleton;

/**
 * @author ：mmzs
 * @date ：Created in 2020/4/12 12:31
 * @description：静态内部类实现单例模式
 * @modified By：
 * @version: $
 */
public class StaticInnerClassSingleton {
    private StaticInnerClassSingleton(){}

    private static class SingleTonHoler{
        private static StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
    }

    public static StaticInnerClassSingleton getInstance(){
        return SingleTonHoler.INSTANCE;
    }
}

枚举模式

优点：

1. 代码简单
2. 自由序列化

用enum实现Singleton时我曾介绍过三个特性，自由序列化，线程安全，保证单例

对于序列化和反序列化，因为每一个枚举类型和枚举变量在JVM中都是唯一的，即Java在序列化和反序列化枚举时做了特殊的规定，枚举的writeObject、readObject、readObjectNoData、writeReplace和readResolve等方法是被编译器禁用的，因此也不存在实现序列化接口后调用readObject会破坏单例的问题。
对于线程安全方面，类似于普通的饿汉模式，通过在第一次调用时的静态初始化创建的对象是线程安全的

package com.phy.java.singleton;

public enum ResponseDto {
    //定义两个实例，一个表示请求成功，一个表示请求失败
    HTTP_200(200,"请求成功"), HTTP_500(500,"请求失败");

    //枚举和普通的类一样，可以定义属性，构造函数，getter setter，普通方法，
    private Integer code;
    private String msg;

    ResponseDto(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public Integer getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public static void main(String [] args){
        System.out.println(ResponseDto.HTTP_200);
        System.out.println(ResponseDto.HTTP_500);
        System.out.println(ResponseDto.HTTP_200==ResponseDto.HTTP_200);
        System.out.println(ResponseDto.HTTP_200.equals(ResponseDto.HTTP_200));
        System.out.println(ResponseDto.HTTP_200.getMsg());
        System.out.println(ResponseDto.HTTP_500.getMsg());
    }
}