单例模式三种实现方式

单例模式

单例模式即实例化对象的过程有且仅有一次

单例模式的分类

饿汉模式

public class HungerySingleton {
    //加载的时候就产生的实例对象
    private static HungerySingleton instance=new HungerySingleton();
    private HungerySingleton(){
    }
 }
```没有线程安全问题（被加载的时候已经被实例化了，所以只会有一次）但是性能不太好，比如从头到尾都没人调用过它


### 懒汉模式（懒加载：延迟加载）
把自己的构造方法设为私有的
#### 懒汉式

```java
public class HoonSingleton {
    private static HoonSingleton instance=null;
    private HoonSingleton(){
    }
    public static HoonSingleton getInstance(){
        if(null==instance)//这个地方会线程不安全
            instance=new HoonSingleton();
        return instance;
    }
}

线程不安全

懒汉式+同步

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

线程安全，但是退化为串行，性能不好

public class HoonSingleton {
    private static HoonSingleton instance=null;
    private HoonSingleton(){
    }
    public  static HoonSingleton getInstance(){
    
        if(null==instance)//这个地方会线程不安全
        synchroized（HoonSingleton.class）{
            instance=new HoonSingleton();
         }   
        return instance;
    }
}

线程不安全

双重标志检查法

public class HoonSingleton {
    private static HoonSingleton instance=null;
    private HoonSingleton(){
    }
    public  static HoonSingleton getInstance(){
    
        if(null==instance)//这个地方会线程不安全
        synchroized（HoonSingleton.class）{
        if(null==instance)//这里使得线程安全
            instance=new HoonSingleton();
         }   
        return instance;
    }
}

但是第二个想去创建的线程会做很多重复的操作和判断

public class HoonSingleton {
    int a = 0;
    private volatile static HoonSingleton instance=null;
    private HoonSingleton(){
    }
    public  static HoonSingleton getInstance(){
    
        if(null==instance)//这个地方会线程不安全
        synchroized（HoonSingleton.class）{
        if(null==instance)//这里使得线程安全
            instance=new HoonSingleton();
         }   
        return instance;
    }
}

volatile不仅保证了对外显示，而且还保证了有序性

内部静态类

public class HolderDemo {
    private HolderDemo(){

    }
    private static class Holder{
        private static HolderDemo instance=new HolderDemo();
    }
    //懒加载
    //synchronized
    //<init>
    public static HolderDemo getInstance(){
        return Holder.instance;
    }

    //广泛的一种单例模式
}

没有使用锁，性能更高

枚举

懒加载

public class EnumSingletonDemo {
    private EnumSingletonDemo(){
    }
    //延迟加载
    private enum EnumHolder{
        INSTANCE;
        private static  EnumSingletonDemo instance=null;

        private EnumSingletonDemo getInstance(){
            instance=new EnumSingletonDemo();
            return instance;
    }
    }//懒加载
    public static EnumSingletonDemo  getInstance(){
        return EnumHolder.INSTANCE.instance;
    }

}

饿汉模式

public enum EnumSingletonDemo {
        INSTANCE;
        private EnumSingletonDemo getInstance(){
            return INSTANCE;
    }
}