Design Pattern [1] —— 单例模式 Singleton
单例模式：一个类只能构造一个实例对象（"构造器私有"）
场景：
Windows任务管理器、回收站
项目中，配置文件的类，一般只有一个对象
网站的计数器、时钟
数据库连接池
Servlet
Spring中的Bean（缓存中取bean很快，减少jvm垃圾回收）（当有请求来的时候会先从缓存(map)里查看有没有，有的话直接使用这个对象，没有的话才实例化一个新的对象）
好文：https://zhuanlan.zhihu.com/p/33102022 （本文还需要进一步根据面经深化）
我的Github里有源码，可以clone下来自己跑下：https://github.com/Yang2199/Design-Pattern/tree/master/src
1）饿汉式单例
==》上来直接new对象，所有类实例化。坏处是：大量浪费不必要的资源（因为很多类 不需要实例化）
public class Hungry {
private Hungry(){} //构造函数
private final static Hungry HUNGRY = new Hungry();//直接实例化，new出对象
public static Hungry getInstance(){
return HUNGRY;
}
}
2）懒汉式单例
==》懒汉模式中单例是在需要的时候才去创建的，如果单例已经创建，再次调用获取接口将不会重新创建新的对象，而是直接返回之前创建的对象。
线程不安全：多个线程可能会并发调用它的getInstance()方法，导致创建多个实例，
因此需要加锁解决线程同步问题（ Synchronized 同步锁来修饰 getInstance 方法）
public class Singleton {
private Singleton() {} //单例=》私有构造器
private static Singleton instance = null; //单例对象
public static Singleton getInstance() { //调用getInstance方法才会开始构造对象
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
但是这种方法不符合线程安全：
public class Singleton {
private Singleton() {
System.out.println(Thread.currentThread().getName()); //构造时候打印线程名
} //私有构造函数
private static Singleton instance = null; //单例对象
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
public static void main(String[] args) {
for(int i =0;i<10;i++){
new Thread( ()->{Singleton.getInstance();} ).start(); //1.启动新线程 2.lambda表达式
}
}
}
可能会出现构造了很多个的情形
方法一：双重锁检测 DCL
==》首先将类加同步锁（syn），但是new语句不是原子操作，所以对了类的实例加volatile锁（可见性）
第一把锁：synchronized锁
public static Singleton getInstance() {
if (instance == null) { //外层判断
synchronized (Singleton.class) { //将Singleton类 加锁
if (instance == null) { //原有判断
instance = new Singleton();
// 上面这行 不是原子操作：
// 1.分配内存空间 2.执行构造方法，初始化对象 3.把这个对象指向这个空间
}
}
}
return instance;
}
//加上两层：一层if、一层锁
//这样就能保证单例在多线程下的唯一性
//双重检查模式：DCL (Double Check)
第二把锁：volatile锁
private volatile static Singleton instance = null; //由于instance = new Singleton()的非原子性（new对象3步），所以需要volatile保证强制同步一致
volatile关键字不但可以防止指令重排，也可以保证线程访问的变量值是主内存中的最新值。
但是，还是可以用反射来破坏DCL：
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
Singleton instance = Singleton.getInstance();
Constructor<Singleton> declaredConstructor =Singleton.class.getDeclaredConstructor(null); //通过反射获取declaredConstructor这个构造器
declaredConstructor.setAccessible(true);
Singleton instance2 = declaredConstructor.newInstance();
System.out.println(instance.hashCode() );
System.out.println(instance2.hashCode() );
}
实现单例模式，3种方法对比：
方法二：用静态内部类
public class Holder {
private Holder(){}
public static Holder getInstance() {return InnerClass.HOLDER;}
private static class InnerClass{
private static final Holder HOLDER = new Holder();
}
}
这个方法也能被反射破坏单例的唯一性
方法三：枚举
==》直接把类名前的class替换成enum就好了，因为枚举无法反射
枚举：（通过查看源码可知，枚举时，无法反射。）
public enum EnumSingleton { //这里是enum而不是class
INSTANCE;
public EnumSingleton getInstance(){
return INSTANCE;
}
}
测试：
class Test{
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
EnumSingleton instance1 = EnumSingleton.INSTANCE.getInstance();
Constructor<EnumSingleton> declaredConstructor = EnumSingleton.class.getDeclaredConstructor(String.class,int.class);
declaredConstructor.setAccessible(true);
EnumSingleton instance2 = declaredConstructor.newInstance();
System.out.println(instance1);
System.out.println(instance2);
}
}
会显示：
异常：枚举无法创造反射
符合预期。
