设计模式：单例模式（7种实现方式）

单例模式，顾名思义就是只有一个实例，并且它自己负责创建自己的对象，这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

1、饿汉式：

/**
 * @Auther: yjntue
 * @Date: 2020/3/4 19:48
 * @Description:
 * 饿汉式 若一个类的成员都是比较重的资源，这种方式不合适
 * 不允许被继承
 */
public class Singleton1 {
    //定义变量时直接进行初始化
    //instance被ClassLoader 加载后很长一段时间才被使用，它所开辟的堆内存会驻留更久
    private static  Singleton1 singleton1 = new Singleton1();
    //一定要为私有构造器,不允许外部new
    private Singleton1(){
    }
    //无法进行懒加载
    public static Singleton1 getInstance(){
        return singleton1;
    }
}

以上代码中instance作为类变量在初始化的过程中会被收集进<clinit>()方法中，该方法能够确保同步，也就是说instance在多线程的情况下不可能被实例化两次，只是instance被ClassLoader 加载后很长一段时间才被使用，instance实例所开辟的堆内存会驻留更久。饿汉式的单例设计模式可以保证多个线程下的唯一实例，但会消耗不必要的内存，在没有使用的情况下。

2、懒汉式（有线程安全问题）

/**
 * @Auther: yjntue
 * @Date: 2020/3/4 19:51
 * @Description:
 * 懒汉式 实例等需要用的时候再去创建
 */
public class Singleton2 {
    //只定义不初始化
    private static Singleton2 singleton2 ;
    //私有构造器，外部不能进行创建
    private Singleton2(){
    }
    //可保证实例的懒加载，但无法保证实例的唯一性
    public static Singleton2 getInstance(){
        if(singleton2 == null){
            singleton2 = new Singleton2();
        }
        return singleton2;
    }
}

以上代码中Singleton2.class被初始化时instance并没有被实例化，getInstance()会判断instance是否被实例化，但是放在多线程的环境下进行分析，若有两个线程同时看到instance为null，那么instance将无法保证单例的唯一性。

3、懒汉式+同步方法

/**
 * @Auther: yjntue
 * @Date: 2020/3/4 19:53
 * @Description:
 * 懒汉式+同步方法
 * 实例等需要用的时候再去创建
 */
public class Singleton3 {
    //只定义不初始化
    private static Singleton3 singleton3 ;
    //私有构造器，外部不能进行创建
    private Singleton3(){
    }
    //向getInstance()加入同步控制，每次只能有一个线程进入
    public synchronized static Singleton3 getInstance(){
        if(singleton3 == null){
            singleton3 = new Singleton3();
        }
        return singleton3;
    }
}

这里instance其实就是共享资源（数据），当多个线程访问时，需要保证数据的同步性，这种方式满足了懒加载又能保证instance实例的唯一性，但是synchronized的排他性导致getInstance()只能在同一时刻被一个线程访问，性能会下降。

4、Double-Check（存在问题）

/**
 * @Auther: yjntue
 * @Date: 2020/3/4 19:55
 * @Description:
 * Double-Check Synchronized
 */
public class Singleton4 {
    //只定义不初始化
    private static Singleton4 singleton4 ;
    //私有构造器，外部不能进行创建
    private Singleton4(){
    }

    public static Singleton4 getInstance(){
        //当instance为null时，进入同步代码块，同时可避免了每次都需要进入同步代码块，可提高效率
        if(singleton4 == null){
            synchronized(Singleton4.class){
                //判断如果instance为null时创建
                if(singleton4 == null){
                    singleton4 = new Singleton4();
                }
            }
        }
        return singleton4;
    }
}

当有两个线程发现null==instance成立时，只有一个线程有资格进入同步代码块，完成对instance的实例化，随后的线程发现null==instance不成立则不进行任何动作，以后对getInstance的访问就不需要数据同步保护了。这种方法既满足了懒加载，又保证了instance实例的唯一性，可以允许多个线程同时对getInstance进行访问，但在多线程的情况下可能会引起空指针。原因是：CPU的指令重排，因为创建一个对象时，JVM会分3个的操作步骤进行，但这种情况，实际发生的概率非常的小，却是存在的隐患。

5、volatile+Double-Check

/**
 * @Auther: yjntue
 * @Date: 2020/3/4 19:57
 * @Description:
 * volatile+Double-Check
 * 高效的数据同步策略,volatile可以防止指令重排序
 */
public class Singleton5 {
    //只定义不初始化
    private volatile static Singleton5 singleton5 ;
    //私有构造器，外部不能进行创建
    private Singleton5(){
    }

    public static Singleton5 getInstance(){
        //当instance为null时，进入同步代码块，同时可避免了每次都需要进入同步代码块，可提高效率
        if(singleton5 == null){
            synchronized(Singleton5.class){
                //判断如果instance为null时创建
                if(singleton5 == null){
                    singleton5 = new Singleton5();
                }
            }
        }
        return singleton5;
    }
}

这种方式满足多线程下的单例、懒加载以及获取实例的高效性。

6、静态内部类

/**
 * @Auther: yjntue
 * @Date: 2020/3/4 20:03
 * @Description:
 * 内部类实现
 * 借助类加载的特点，单例设计的最好方式之一
 */
public class Singleton6 {
    //私有构造器，外部不能进行创建
    private Singleton6(){
    }
    //在静态内部类中持有Singleton的实例，并且可直接被初始化
    private static class SingletonHolder{
        private static Singleton6 singleton6 = new Singleton6();
    }
    //调用getInstance方法，事实上获得SingletonHolder的instance静态属性
    public static Singleton6 getInstance(){
        return SingletonHolder.singleton6;
    }
}

在Singleton6初始化的过程中不会创建Singleton6的实例，静态内部类SingletonHolder中定义了Singleton6的静态变量，并直接实例化，当SingletonHolder被主动引用时会创建Singleton6的实例，Singleton6实例的创建在Java编译时期收集在<clinit>()中，该方法又是同步方法，可以保证内存的可见性、JVM指令的顺序性以及原子性。

7、枚举

/**
 * @Auther: yjntue
 * @Date: 2020/3/4 21:14
 * @Description:
 * 枚举实现单例模式 最佳实践
 */
public enum EnumSingleton {
    INSTANCE;
    private static void doSomething(){
        //调用该方法会主动使用Singleton,INSTANCE将会被实例化
    }
    //调用getInstance方法，事实上获得Holder的instance静态属性
    public static EnumSingleton getInstance(){
        return INSTANCE;
    }
}

在effective java（这本书真的很棒）中说道，最佳的单例实现模式就是枚举模式。利用枚举的特性，让JVM来帮我们保证线程安全和单一实例的问题。除此之外，写法还特别简单。直接通过EnumSingleton .INSTANCE.doSomething()的方式调用即可。方便、简洁又安全。