单例模式的概念

单例模式就是确保只有一个实例，而且自行实例化并向整个系统传递这个实例，这个类就称作为单例类

单例模式最重要的一个特点就是构造方法私有化。创建单例模式分为懒汉式和饿汉式。

第一种：懒汉式（线程不安全的）

传统的懒汉式创建单例模式，是线程不安全的

public class Singleton {    
    private static Singleton instance;    
    private Singleton (){}    
    
    public static Singleton getInstance() {    
    if (instance == null) {    
        instance = new Singleton();    
    }    
    return instance;    
    }    
} 

所谓懒汉式单例模式就是在调用的时候才去创建这个实例。这种写法的懒加载很明显，但是缺点就是不能再多线程访问下正常工作。

第二种：懒汉式（线程安全的）

public class Singleton {    
    private static Singleton instance;    
    private Singleton (){}    
    public static synchronized Singleton getInstance() {    
    if (instance == null) {    
        instance = new Singleton();    
    }    
    return instance;    
    }    
}  

线程安全的方式创建单例就是在对外的创建实例方法上加上synchronized。 这种写法能够在多线程中很好的工作，而且看起来它也具备很好的lazy loading，但是，遗憾的是，效率很低，99%情况下不需要同步。

第三种：饿汉式（是线程安全的）

public class Singleton {    
    private static Singleton instance = new Singleton();    
    private Singleton (){}    
    public static Singleton getInstance() {    
    return instance;    
    }    
}   

这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用getInstance方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到lazy loading的效果。

第四种：静态内部类的方式创建单例模式（static inner class）

public class Singleton {
    private Singleton() {
    }
    private static class SingletonHolder {// 静态内部类
        private static Singleton singleton = new Singleton();
    }
    public static Singleton getInstance() {
        return SingletonHolder.singleton;
    }
}

这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程，它跟第三种方式不同的是（很细微的差别）：第三种方式是只要Singleton类被装载了，那么instance就会被实例化（没有达到lazy loading效果），而这种方式是Singleton类被装载了，instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化singleton。想象一下，如果实例化singleton很消耗资源，我想让他延迟加载，另外一方面，我不希望在Singleton类加载时就实例化，因为我不能确保Singleton类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化instance显然是不合适的。这个时候，这种方式相比第三种方式就显得很合理。

第五种：双重校验锁（dubble check instance）

public class Singleton {  
  
    private static Singleton singleton;  
    private Singleton() {  
    }  
    public static Singleton getInstance(){  
        if (singleton == null) {  
            synchronized (Singleton.class) {  
                if (singleton == null) {  
                    /** 
                     * 为什么这里会使用双重判定呢？ 
                     */  
                    singleton = new Singleton();  
                }  
            }  
        }  
        return singleton;  
    }  
}  

这种事用双重判断来创建一个单例的方法，那么我们为什么要使用两个if判断这个对象当前是不是空的呢 ？因为当有多个线程同时要创建对象的时候，多个线程有可能都停止在第一个if判断的地方，等待锁的释放，然后多个线程就都创建了对象，这样就不是单例模式了，所以我们要用两个if来进行这个对象是否存在的判断。

参考：
https://blog.csdn.net/a347911/article/details/53321803