单例模式是一种对象创建型模式，使用单例模式，可以保证为一个类只生成唯一的实例对象。也就是说，在整个程序空间中，该类只存在一个实例对象。

一、饿汉式

public class HungerySingleton {
    //加载的时候就创建对象
    private static HungerySingleton instance= new HungerySingleton();
    private HungerySingleton(){
    }

    //返回实例对象
    public static HungerySingleton getInstance(){
        return instance;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                System.out.println(HungerySingleton.getInstance());
            }).start();
        }
    }
}

1.1、线程安全性

1.2、缺点

二、懒汉式

public class HoonSynSingletonDemo01 {
    private static HoonSynSingletonDemo01 instance = null;

    private HoonSynSingletonDemo01() {
    }

    public static HoonSynSingletonDemo01 getInstance() {
        //调用getInstance静态方法，非Null才创建。
        if (null == instance) {
            instance = new HoonSynSingletonDemo01();
        }
        return instance;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                System.out.println(HoonSynSingletonDemo01.getInstance());
            }).start();
        }
    }
}

线程安全性

2.1、解决方案1-同步方法

public synchronized static HoonSynSingletonDemo01 getInstance() {
    //调用getInstance静态方法，非Null才创建。
    if (null == instance) {
        instance = new HoonSynSingletonDemo01();
    }
    return instance;
}

2.2、解决方案2-DCL(Double-Check-Locking)

public static HoonSynSingletonDemo01 getInstance() {
    //第一次判断
    if (null == instance) {
        synchronized (HoonSynSingletonDemo01.class){
            instance = new HoonSynSingletonDemo01();
        }
    }
    return instance;
}

DCL(Double-Check-Locking)双重检查锁，即可解决这个问题

public static HoonSynSingletonDemo01 getInstance() {
    //第一次判断
    if (null == instance) {
        synchronized (HoonSynSingletonDemo01.class){
            //同步代码块中，也要再次判断
            if (null == instance){
                instance = new HoonSynSingletonDemo01();
            }
        }
    }
    return instance;
}

2.3、问题思考

public class HoonSynSingletonDemo02 {
    private int id;
    private static HoonSynSingletonDemo02 instance = null;

    private HoonSynSingletonDemo02() {
        id = new Random().nextInt(100) + 1;                         //(1)
    }

    public static HoonSynSingletonDemo02 getInstance() {
        //第一次判断
        if (null == instance) {                                     //(2)
            synchronized (HoonSynSingletonDemo02.class){            //(3)
                //同步代码块中，也要再次判断
                if (null == instance){                              //(4)
                    instance = new HoonSynSingletonDemo02();        //(5)
                }
            }
        }
        return instance;                                             //(6)
    }

    public void getId(){
        System.out.println("id:" + this.id);             //(7)
    }
}

利用Happen-Before规则分析DCL

1. 如果一个操作happens-before另一个操作，那么第一个操作的执行结果将对第二个操作可见，而且第一个操作的执行顺序排在第二个操作之前(如果A happens-before B，那么Java内存模型将向程序员保证——>A操作的结果将对B可见，且A的执行顺序排在B之前)。
   

2. 两个操作之间存在happens-before关系，并不意味着Java平台的具体实现必须要按照happens-before关系指定的顺序来执行。如果重排序之后的执行结果，与按happens-before关系来执行的结果一致，那么这种重排序并不非法（也就是说，JMM允许这种重排序）。

DCL问题解决

private volatile static HoonSynSingletonDemo02 instance = null;

根据volatile规则，可以得到：线程1的语句(5) ——> 语线程2的句(2)。根据单线程规则，可以得到：线程1的语句(1) ——> 线程1的语句(5)和语线程2的句(2) ——> 语线程2的句(7)。再根据传递规则，可以得到：线程1的语句(1) ——> 线程2的句(7)。这表示线程2能够观察到线程1在语句(1)时对id的写入值，程序能够得到正确的行为。也可以通过final关键字修饰instance，也可以解决这个问题。

2.4、解决方案3-静态内部类

利用classloder的机制来保证初始化instance时只有一个线程。

public class Singleton {
    private static class SingletonHolder{
        public static Singleton singleton = new Singleton();
    }

    public static Singleton getInstance(){
        return SingletonHolder.singleton;
    }
}

2.5、解决方案3-Holder模式

声明类的时候，成员变量中不声明实例变量，而放到内部静态类中。这也是广泛的一种单例模式。

public class HolderDemo {
    private HolderDemo(){
    }
    
    private static class Holder{
        private static HolderDemo instance = new HolderDemo();
    }

    public static HolderDemo getInstance(){
        return Holder.instance;
    }
}

2.6、解决方案3-枚举

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