单例模式

单例模式分为两种：饿汉式 和 懒汉式。

参考：知乎-如何学习设计模式？

饿汉式

（因为很饿，所以在变量声明时就初始化）

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

缺点：即使这个单例类不需要使用，也会在类加载的时候被创建出来。增大了内存开销，浪费内存。

是线程安全的。

跟着下面的几种方式全属于懒汉式了，只不过有几种变形而已。

懒汉式

（先声明一个null变量，在对象使用的时候变量才被初始化）

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

解决饿汉式内存浪费的缺点。

但是线程不安全。

懒汉加锁式

有没有又线程安全，又不浪费内存的写法？ 有,getInstance()方法里面加个锁。

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

但是缺点也很明显，效率低(毕竟用到了synchronized)。且这里每次调用getInstance()时候就会synchronized一次，太低效了。所以可以在synchronized之前判空一次，如果instance不为空，就不用synchronized了。

写法如下：

双重校验锁（DCL，即 double-checked locking）

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

线程安全了，也不浪费内存，同时效率还提升了。

非要说有什么缺点的话，emmm...，写起来太麻烦了。

其实还有个问题，JVM底层为了优化程序运行效率，可能会对代码进行指令重排序，导致某些特殊情况下仍然线程不安全。

所以有时候会看到给instance变量加上volatile关键字的写法，就是为了解决这个问题。

最后还有一种比较常见的方式：

懒汉静态内部类

class XX{
    //静态内部类
    private static class  XXHolder{
        public static XX  instance = new XX() ;
    }
    
    private XX(){}
    
    public XX getInstance{
        return XXHolder.instance;
    }
}

以内部类的形式存放单例对象，当类加载的时候，内部类不会立即加载，而是当类使用的时候才会被加载，所以就做到了不浪费内存。

Java虚拟机中有相关机制保证内部类的线程安全，所以它也是线程安全的。

方式选择

不提倡具体应该使用哪种方式，应该根据业务场景来权衡。

一般情况下（构建完直接使用），推荐饿汉式；

懒汉式属于懒加载的范畴，懒加载嘛，加载时间延后，启动快了，但是后续加载就需要时间了。所以要根据具体场景来判断使用哪种方式。

所以当明确要使用懒加载的情况下，就使用静态内部类的方式。

其他方式特殊情况下特殊考虑。