设计模式 --- 单例模式

    单例模式，就是在程序中只有一个实例。该类自己创建自己的对象，同时确保只有一个对象被创建。

    其实现主要是：

1. 将构造方法定义为private，这样确保只有该类可以获得唯一实例
2. 提供一个静态的方法，用于获取实例，为空就创建一个否则返回。

实现方式

懒汉式

public class LazySingle {
    private static LazySingle lazySingle;

    //私有构造方法
    private LazySingle() {
    }

    //只有在需要的时候去创建，如果有则返回，没有则新建
    public static LazySingle getInstance(){
        if(lazySingle == null ){
            lazySingle = new LazySingle();
        }
        return lazySingle;
    }
}

    只有在使用的时候去创建，多线程下有问题，可能导致多个实例。可以通过添加synchronized解决问题，但是不能乱加，如果直接加在方法getInstance上，迫使每个线程在进入这个方法前，要先等其他线程调用完，从而保证了单例的有效，但是效率低。可以改为同步代码块的方式，但是并不能做到线程安全，也可能产生多个实例，需要再加一个空判断，然后就变成了双重校验的没事了。

饿汉式

public class HungarySingle {
    //实例在初始化的时候就已经建好了
    //没有线程安全的问题，但是浪费内存空间。
    private static HungarySingle hungarySingle = new HungarySingle();

    private HungarySingle() {
    }

    public static HungarySingle getInstance(){
        return hungarySingle;
    }
}

    被加载的时候，实例一个对象用于引用，而且在整个生命周期只会被加载一次，所以保证单例。在类装载的时候就完成实例化。避免了线程同步问题，但是如果不适用这个类，会造成内存的浪费。

双重锁模式

public class DoubleLockSingle {
    //对象在创建的时候可能重排序，避免在多线程访问下存在风险，保证在写操作没有完成之前不能调用读操作。
    private volatile static DoubleLockSingle single;

    private  DoubleLockSingle(){}

    //进行了两次的判断
    public static DoubleLockSingle getInstance(){
        //避免不要的实例
        if(single == null ){
            synchronized (DoubleLockSingle.class){
                //避免多线程问题
                if(single == null){
                    single = new DoubleLockSingle();
                }
            }
        }
        return single;
    }
}

静态内部类模式

public class InnerSingle {
    private static class Inner{
        private static final InnerSingle single = new InnerSingle();
    }

    private InnerSingle(){}

    //只有第一次调用getInstance方法时，虚拟机才加载 Inner 并初始化instance ，
    // 只有一个线程可以获得对象的初始化锁，其他线程无法进行初始化，保证对象的唯一性
    public static InnerSingle getInstance(){
        return Inner.single;
    }
}

只有在被调用的时候才加载，类似懒汉式的感觉

枚举单例

public enum SingleEnum {
    INSTANCE;

    //可以通过Singleton.INSTANCE进行操作
    public static SingleEnum getInstance(){
        return SingleEnum.INSTANCE;
    }
}

可以防止反射创建单例，其他的方式可以通过校验位来实现。在私有构造方法中添加一个校验

也可以防止克隆情况下产生多个

场景

如果某个对象的产生需要消耗大量资源，为避免频繁的创建以及销毁对资源的浪费；或者某种对象只能存在一个