单例模式

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

饿汉式

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

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;
    }
}