设计模式之单例模式（Singleton）

单例模式是什么

单例模式我个人理解是某个对象只能有一个官方说法可以查百度百科，在生活中有很多这样的例子，只能是唯一的，比如某国家的主席或总统，比如每片雪花，我们每个人也是独一无二的。在这个对象在开发中只能有一个的时候，单例模式就派上了用场。

单例模式简单实现

单例模式三个重要的点就是构造方法私有化、实例化的变量引用私有化、获取实例的方法公有。
我们先看下面一段代码感受一下单例模式。

public class Singleton {
	// 实例化的变量引用私有化
    private static Singleton instance;
    
    // 构造方法私有化
    private Singleton() {
        
    }
    // 获取实例的方法公有
    public static Singleton getInstance() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

public class Client {
    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        
        System.out.println(s1 == s2);
    }
}

//结果
//true

单例模式的常见五种写法

懒汉式

懒汉式最大的特点就是实例在要用的时候才会创建。上面的例子就是懒汉式的写法。

public class LanHan {
    private LanHan instance = null;
    private LanHan {
        
    }
    public LanHan getInstance() {
        // 用到的时候才会创建
        if(instance == null) {
            instance = new LanHan();
        }
        return instance;
    }
}

饿汉式

饿汉式的实例在类初始化的时候就已经创建好了，还没用就二话不说先创建好，有好处也有坏处，好处就是没有线程安全的问题，坏处就是会浪费内存空间，万一我创建好了但是一次都不用不就亏了。

public class EHan {
	// 类初始化的时候就创建
    private LanHan instance = new LanHan();
    private EHan {
        
    }
    
    public EHan getInstance {
        return instance;
    }
}

双重检验锁（DCL）

不知道你有没有发现，这就是懒汉式的线程安全写法。
这段代码有三个点是需要注意的，往下看。

public class DoubleCheckLock {
    private volatile static DoubleCheck instance;
    private DoubleCheckLock {
        
    }
    //同步锁保证多线程安全
    public static DoubleCheckLock getInstance() {
        if(instance == null) {
            synchronized (DoubleCheckLock.class) {
                if(instance == null) {
                    instance = new DoubleCheckLock();
                }
            }
        }
        return instance;
    }
}

为什么不直接锁住整个方法

其实我们可以用一把锁直接锁住整个getInstance()方法，但是这样的方法太消耗时间了，如果很多个线程来抢这个锁的话，为什么具体参考这篇博客：synchronize锁升级。

为什么要检验两次

假设我们只检验一次：

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

那么如果两个线程同时走到synchronized这一行来争夺锁的时候，一个线程（线程①）成功进去了，另一个线程（线程②）就得在外面等着对吧，那么当线程① new对象完出去之后线程②也进去了，然后就又new了一个对象，那岂不是有了两个对象了，所以要在里面再进行一次检验，才能确保只new了一个对象。

为什么instance要被volatile修饰

研究这个问题我们首先要知道，一个对象被创建在java里是只有一行语句，而在计算机底层是要用好几条指令去完成的。大体上步骤是这样的：先分配出装对象的内存 --> 初始化对象 --> 将引用指针指向对象所在的内存空间。
另外计算机底层会有一个指令重排序的机制，也就是happens-before原则：

1. 如果A happens-before B，那么A的执行结果将对B可见，而且A的执行顺序排在B之前。
2. 两个操作之间存在happens-before关系，并不意味着一定要按照happens-before原则制定的顺序来执行。如果重排序之后的执行结果与按照happens-before关系来执行的结果一致，那么这种重排序并不非法。

所以其实计算机底层先将指针指向内存空间再将对象初始化也是可以的，并不非法，那么如果一个线程（线程①）过来，另一个线程（线程②）在new对象，发生了重排序，那么线程①拿到的对象还没初始化，但是线程①又拿着还没初始化的对象去做某些操作，那肯定是要报错的。
我们都知道volatile有禁止指令重排序的作用（为什么有这个功能，请等我接下来的博客），所以instance要被volatile修饰，才能安全。

静态内部类

静态内部类的写法就有很多优点了，因为外部类加载的时候并不要立即加载内部类，所以实现了懒加载；又因为instance实例是内部类的类变量，所以只会new一次，保证了多线程环境下也只有一个对象。

public class SingleInnerClass {
    private SingleInnerClass() {
        
    }
    private static class SingleHolder {
        static final SingleInnerClass instance = new SingleInnerClass();
    }
    public static SingleInnerClass getInstance() {
        return SingleHolder.instance;
    }
}

枚举

默认枚举实例的创建是线程安全的，并且在任何情况下都是单例（具体原因等我的后续博客）。枚举类隐藏了私有的构造器、枚举类的域是相应类型的一个实例对象。

public enum SingleEnum {
    INSTANCE;
    public SingleEnum getInstance() {
		return INSTANCE;
	}
}

如何防止反射创建单例

1. 使用枚举的方式创建单例
   枚举防止反射的方式请看后续博客。

2. 在构造函数处使用标记

   /*
   	防止反射创建单例
   */
   public class SingleReflect {
       private static boolean flag = true;
       private SingleReflect() {
           if(flag) {
               flag = false;
           } else {
               throw new RuntimeException("init one more time");
           }
       }
       public static SingleReflect instance = new SingleReflect();
       public static SingleReflect getInstance() {
           return instance;
       }
   }
   
   /*
   	主函数调用
   */
   public class Main {
       public static void main(String[] args) {
           try {
               Class classType = SingleReflect.class;
               Constructor constructor = classType.getDeclaredConstructor();
               //要使用私有构造器，必须先设置 constructor.setAccessible(true)
               constructor.setAccessible(true);
               System.out.println(SingleReflect.getInstance() == constructor.newInstance());
           } catch(Exception e) {
               e.printStackTrace();
           }
       }
   }
   
   
   //输出结果
   /*
   	java.lang.reflect.InvocationTargetException
   	at java.base/jdk.internal.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
   	at java.base/jdk.internal.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
   	at java.base/jdk.internal.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
   	at java.base/java.lang.reflect.Constructor.newInstance(Constructor.java:490)
   	at Singleton.Main.main(Main.java:11)
   Caused by: java.lang.RuntimeException: init one more time
   	at Singleton.SingleReflect.<init>(SingleReflect.java:9)
   	... 5 more
   */
   

如有错误，欢迎指正！