参考：https://www.cnblogs.com/jing-an-feng-shao/p/7495048.html
1 单例模式
《Head First 设计模式》：确保一个类只有一个实例，并提供一个全局访问点
其目的在于减少系统对于同一个对象的创建和销毁，从而减少内存的开销。
2 实现方法
2.1 饿汉模式
思想：
饿汉模式是最常提及的2种单例模式之一，其核心思想，是类持有一个自身的 instance 属性，并且在申明的同时立即初始化。
同时，类将自身的构造器权限设为 private，防止外部代码创建对象，对外只提供一个静态的 getInstance() 方法，作为获取单例的唯一入口。
public class EagerSingleton {
private final static EagerSingleton instance = new EagerSingleton();
private EagerSingleton () {
if(instance != null) { //使构造器只能被调用一次
throw new IllegalStateException();
}
}
public static EagerSingleton getInstance() {
return instance;
}
}
三个要点：
- 构造器为私有，使用公共静态方法获取实例
- 类持有持有一个自身的成员变量并且声明时立即初始化
- 构造器内部添加if(instance != null)(throw new IllegalStateException();)来限定构造方法只被调用一次，这样反射在调用构造方法时就会报错
测试Demo如下：
public class DemoSingleton {
public static void main(String[] args) {
EagerSingleton e1 = EagerSingleton.getInstance();
EagerSingleton e2 = EagerSingleton.getInstance();
System.out.println(e1 == e2); //结果为true
//使用方式调用构造器新建实例
try {
Class<?> eagerSingletonClass = Class.forName("EagerSingleton");
Constructor<?> declaredConstructorBook = eagerSingletonClass.getDeclaredConstructor();
declaredConstructorBook.setAccessible(true);
Object e = declaredConstructorBook.newInstance(); //调用构造器返回IllegalStateException异常
System.out.println(e == e1); //如果构造器没限定代码会打印出false，说明没有限定代码反射可以打破单例
} catch (ClassNotFoundException | InstantiationException
| IllegalAccessException | NoSuchMethodException
| SecurityException | IllegalArgumentException | InvocationTargetException e) {
e.printStackTrace();
}
}
}
- 为什么在私有构造器中加入对 instance 属性的空校验？
为了阻止反射的入侵，从而打破单例。 - 多线程的情况下会不会打破单例？
不会，因为 EagerSingleton 是在加载类的同时进行对象的创建，所以即使在多线程并发的情况下，仍然可以保证单例。 - 优势？劣势？
在加载类的同时创建单例对象，如果这个对象不是立刻需要使用的，会额外增加内存的消耗。
2.2 懒汉模式
思想：
相比于饿汉模式，懒汉模式实际中的应用更多，因为在系统中，“被用到时再初始化”是更佳的解决方案。
设计思想与饿汉模式类似，同样是持有一个自身的引用，只是将 new 的动作延迟到 getinstance() 方法中执行。
class LazySingleton {
private static LazySingleton instance;
private LazySingleton() {
if(instance != null) {
throw new IllegalStateException();
}
}
public static synchronized LazySingleton getInstance() {
if(instance == null) {
instance = new LazySingleton();
}
return instance;
}
}
- 反射能否打破单例？
对于 LazySingleton，这是个很有趣的问题，虽然我们在私有构造器中增加了 instance==null 的判断，但是由于延迟加载的原因，使得它无法完美地规避反射的入侵。这涉及到了反射入侵和 getInstance() 方法调用顺序的问题。如果在调用 getInstance() 方法之前进行反射入侵，那么就会打破单例，反之，可以保证单例。 - 同步方法带来的性能问题？
可以使用 synchronized 代码块 + Double-check Locking + volatile 关键字 - 优势？劣势？
优势：延迟加载。
劣势：不能完全屏蔽反射入侵，而且代码较为繁琐。
2.3 静态内部类模式
class StaticInnerSingleton {
private static class Holder {
private static StaticInnerSingleton instatnce = new StaticInnerSingleton();
}
private StaticInnerSingleton () {
if(Holder.instatnce != null) {
throw new IllegalStateException();
}
}
public static StaticInnerSingleton getInstance() {
return Holder.instatnce;
}
}
- 反射能否打破单例？
首先，对外部类的私有构造器中加入 instance==null 的判断，防止反射入侵外部类。
其次，静态内部类保证了从外部很难获取 SingletonHolder 的 Class 对象，从而保证了内部类不会被反射。 - 多线程能否打破单例？
Holder 模式借用了饿汉模式的优势，就是在加载类（内部类）的同时对 instance 对象进行初始化。
由于自始至终类只会加载一次，所以即使在多线程的情况下，也能够保持单例的性质。 - 优势？劣势？
优势：兼顾了懒汉模式的内存优化（使用时才初始化）以及饿汉模式的安全性（不会被反射入侵）。
劣势：需要多加载一个类；相比于懒汉模式，Holder 创建的单例，只能通过 JVM 去控制器生命周期，不能手动 destroy。
3 总结
| 实现方法 | 优势 | 劣势 | 阻止反射入侵 | 阻止多线程入侵 |
|---|---|---|---|---|
| 饿汉模式 | 额外增加内存的消耗 | √ | √ | |
| 懒汉模式 | 延迟加载 | 不能完全屏蔽反射入侵 | × | √ |
| 静态内部类模式 | 延迟加载 | 只能通过 JVM 去控制器生命周期，不能手动 destroy | √ | √ |
网友评论