Java单例模式

一、定义

    单例模式确保某个类只有有一个实例，而且自行实例化向整个系统提供这个实例。在计算机系统中线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设置成单例。

二、特点

    1、单例类只有一个实例；
    2、单例类必须自己创建自己的唯一实例；
    3、单例类必须给所有其他对象提供这一实例；

三、实现单例模式的方式

1、饿汉式单例（立即加载模式）

//饿汉模式
public class Singleton1 {
    private Singleton1(){}
    
    private static Singleton1 single = new Singleton1();
    
    public static Singleton1 getInstance(){
        return single;
    }
}

特点：（1）私有构造，防止外部实例化（通过反射是可以实例化的，不考虑这种情况）
           （2）声明静态私有类变量，立即实例化，保证实例化一次
           （3）提供public的getInstance()方法供外部获取单例实例
           （4）优点：线程安全，获取实例速度快；缺点：类加载即初始化实例，内存浪费

2、懒汉式单例（延迟加载模式）

//普通懒汉模式
public class Singleton2 {
    
    private Singleton2(){}
    
    private static Singleton2 single = null;
    
    public static Singleton2 getInstance(){
        if(single == null){
            single = new Singleton2();
        }
        return single;
    }
}

特点：（1）优点：在获取实例的方法中，进行实例的初始化，节省系统资源；
           （2）缺点：如果获取实例时，初始化工作较多，加载速度会变慢，影响系统性能
           （3）缺点：每次获取实例都要进行非空检查，系统开销大
           （4）缺点：非线程安全，当多个线程同时访问getInstance()时，可能会产生多个实例

//同步锁懒汉模式
public class Singleton3 {

    private Singleton3(){}

    private static Singleton3 single = null;

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

特点： 优点：线程安全；缺点：每次获取实例都要加锁，耗费资源，其实只要实例生成，以后获取就不需要再锁了

//双重检查锁懒汉模式
public class Singleton4 {
    
    private Singleton4(){}
    //单例使用volatile修饰
    //1、禁止指令重排，2、保证变量可见性
    private static volatile Singleton4 single = null;
    
    public static Singleton4 getInstance(){
        if(single == null){
            synchronized (Singleton4.class){
                if(single == null){
                    single = new Singleton4();
                }
            }
        }
        return single;
    }
}

特点： 线程安全，进行双重检查，保证只在实例未初始化前进行加锁，效率高；缺点：还是实例非空判断，耗费一定资源

为什么使用volatile修饰singleton后还用synchronized锁？
volatile只是保证了共享变量singleton的可见性，但是 singleton=new Singleton()；这个操作不是原子的，可以分为（1）在堆内申请一块内存空间；（2）初始化申请好的内存空间；（3）将内存空间的地址赋值给singleton；这三步需要保证原子性，所以用synchronized锁

为什么判空一次后还需要进行第二次判空？
A线程进行判空检查后开始执行synchronized代码块时发生线程切换，B线程也进行判空检查，B线程检查singleton==null 结果为 true，也开始执行synchronized代码块，虽然synchronized让两个线程串行执行，但A线程执行时如果没有二次判空，会使singleton初始化两次

3、静态内部类

public class Singleton5 {

    private Singleton5(){}

    private static class InnerObject{
        private static Singleton5 single = new Singleton5();
    }

    public static Singleton5 getInstance(){
        return InnerObject.single;
    }
}

特点： 静态内部类保证了线程安全，但在遇到序列化对象时，默认的方式得到的结果就是多例的；这种情况不多做说明，使用时请注意。

4、静态代码块

public class Singleton6 {

    private Singleton6(){}
    
    private static Singleton6 single = null;
 
    static{
        single = new Singleton6();
    } 

    public static Singleton6 getInstance(){
        return single;
    }
}

5、内部枚举类

public class SingleFactory {
    private enum EnumSingleton{
        Singleton;
        private Singleton7 single;
        
        private EnumSingleton(){
            single = new Singleton7();
        }
        
        public Singleton7 getInstance(){
            return single;
        }
    }
    public static Singleton7 getInstance(){
        return EnumSingleton.Singleton.getInstance();
    }
}
class Singleton7{
    public Singleton7(){}
}