引言-面向对象设计原则
- 单一职责原则
- 开闭原则
- 里氏替换原则
- 接口隔离原则
- 依赖倒置原则
- 迪米特原则
什么是单例模式
顾名思义，用来保证一个对象只能创建一个实例。
这种模式属于创建型模式
单例模式的特点
- 单例类只能有一个构造函数,并且是私有的
- 单例类必须自己创建自己的唯一实例
- 单例类必须给所有其他对象提供这一实例。
单利模式的优缺点
- 优点:在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例
- 缺点:没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。
实现单例模式的方式
(1)饿汉式单例
<1> 优点：没有加任何的锁、执行效率比较高，在用户体验上来说，比懒汉式更好。
<2>缺点：类加载的时候就初始化，不管用与不用都占着空间，浪费了内存，有可能占着茅坑不拉shi
public class HungrySingleton {
//私有的构造函数
private HungrySingleton() { }
//自己创建自己的实例
private static final HungrySingleton hungrySingleton = new HungrySingleton();
//向其他对象提供这一实例
public static HungrySingleton getInstance() {
return hungrySingleton;
}
}
(2)懒汉式单例
<1>优点：延迟加载
<1>缺点：线程不安全，必须加锁 synchronized 才能保证单例，但加锁会影响效率。
public class LazySimpleSingleton {
//私有的构造函数
private LazySimpleSingleton() {}
private static LazySimpleSingleton lazy = null;
//实例化对象并提供这一实例
public static LazySimpleSingleton getInstance() {
if (lazy == null) {
lazy = new LazySimpleSingleton();
}
return lazy;
}
}
(3)双重检查锁单例
<1>优点：这种方式采用双锁机制，安全且在多线程情况下能保持高性能。
public class LazyDoubleCheckSingleton {
private volatile static LazyDoubleCheckSingleton lazy = null;
private LazyDoubleCheckSingleton() { }
public static LazyDoubleCheckSingleton getInstance() {
if (lazy == null) {
synchronized (LazyDoubleCheckSingleton.class) {
if (lazy == null) {
lazy = new LazyDoubleCheckSingleton();
}
}
}
return lazy;
}
}
(4)静态内部类单例
<1>延迟加载(使用的时候才会实例化),避免项目启动内存的消耗
<2>内部类一定是在方法调用之前初始化，巧妙地避免了线程安全问题
public class LazyInnerClassSingleton implements Serializable {
// 私有的构造方法
private LazyInnerClassSingleton(){}
// 公有的获取实例方法
public static final LazyInnerClassSingleton getInstance(){
return LazyHolder.LAZY;
}
// 静态内部类
private static class LazyHolder{
private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
}
}
如何破坏单例？
(1)反射
<1>破坏静态内部类单例
public static void main(String[] args) {
try {
//很无聊的情况下，进行破坏
Class<?> clazz = LazyInnerClassSingleton.class;
//通过反射拿到私有的构造方法
Constructor c = clazz.getDeclaredConstructor(null);
//因为要访问私有的构造方法,这里要设为true,相当于让你有权限去操作
c.setAccessible(true);
//暴力初始化
Object o1 = c.newInstance();
//调用了两次构造方法，相当于 new 了两次
Object o2 = c.newInstance();
//这里输出结果为false
System.out.println(o1 == o2);
} catch (Exception e) {
e.printStackTrace();
}
}
输出为假，说明内存地址不同，就是实例化了多次，破坏了单例模式的特性。
<2>防止反射破坏单例模式
public class LazyInnerClassSingleton {
// 私有的构造方法
private LazyInnerClassSingleton(){
// 防止反射创建多个对象
if(LazyHolder.LAZY != null){
throw new RuntimeException("不允许创建多个实例");
}
}
// 公有的获取实例方法
public static final LazyInnerClassSingleton getInstance(){
return LazyHolder.LAZY;
}
// 静态内部类
private static class LazyHolder{
private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
}
}
多次创建抛出异常
java.lang.reflect.InvocationTargetException
at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
at com.cl.singleton.LazySingletonTest.main(LazySingletonTest.java:68)
Caused by: java.lang.RuntimeException: 只能实例化1个对象
at com.cl.singleton.LazyInnerClassSingleton.<init>(LazyInnerClassSingleton.java:18)
... 5 more
(2)序列和反序列化
<1> 序列化破坏单例模式
//序列化创建单例类
public static void main(String[] args) {
LazyInnerClassSingleton s1 = null;
//通过类本身获得实例对象
LazyInnerClassSingleton s2 = LazyInnerClassSingleton.getInstance();
FileOutputStream fos = null;
try {
//序列化到文件中
fos = new FileOutputStream("SeriableSingleton.obj");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(s2);
oos.flush();
oos.close();
//从文件中反序列化为对象
FileInputStream fis = new FileInputStream("SeriableSingleton.obj");
ObjectInputStream ois = new ObjectInputStream(fis);
s1 = (LazyInnerClassSingleton) ois.readObject();
ois.close();
//对比结果,这里输出的结果为false
System.out.println(s1 == s2);
} catch (Exception e) {
e.printStackTrace();
}
}
结果为假，说明也破坏了单例模式
<2>防止序列化破坏单例模式
public class LazyInnerClassSingleton implements Serializable {
private static final long serialVersionUID = -4264591697494981165L;
// 私有的构造方法
private LazyInnerClassSingleton(){
// 防止反射创建多个对象
if(LazyHolder.LAZY != null){
throw new RuntimeException("只能实例化1个对象");
}
}
// 公有的获取实例方法
public static final LazyInnerClassSingleton getInstance(){
return LazyHolder.LAZY;
}
// 静态内部类
private static class LazyHolder{
private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
}
// 防止序列化创建多个对象,这个方法是关键
private Object readResolve(){
return LazyHolder.LAZY;
}
}
单例模式的最佳实践--枚举
这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化
public enum Singleton {
INSTANCE;
public void whateverMethod() {
}
}
经验
一般情况下，不建议使用懒汉方式，建议使用 饿汉方式。只有在要明确实现 lazy loading 效果时，才会使用内部类方式。如果涉及到反序列化创建对象时，枚举方式。如果有其他特殊的需求，可以考虑使用双检锁方式。
