文章目录
1. 单例模式(Singleton Pattern)
1.1 基本介绍
-
定义:单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。
-
注意事项:
-
单例类只能有一个实例。
-
单例类必须自己创建自己的唯一实例。
-
单例类必须给所有其他对象提供这一实例。
-
1.2 使用场景
- 创建的一个对象需要消耗的资源过多,比如 I/O 与数据库的连接等。
- 创建对象时耗时过多或耗费资源过多,但又经常用到的对象。
- 要求生产唯一序列号。
- WEB 中的计数器,不用每次刷新都在数据库里加一次,用单例先缓存起来。
1.3 优缺点
-
优点:
- 系统内存中该类只存在一个对象,节省了系统资源,对于一些需要频繁创建销毁的对象,使用单例模式可以提高系统性能。
- 避免对资源的多重占用(比如写文件操作)。
-
缺点:
- 没有接口,不能继承,与单一职责原则冲突,一个类应该只关心内部逻辑,而不关心外面怎么样来实例化。
1.4 具体实现
- 基本思路:
- 单例类的构造函数为私有。
- 提供一个自身的静态私有成员变量。
- 提供一个公有的静态工厂方法。
- 实现方式选择:一般情况下,建议使用饿汉方式。只有在要明确实现 lazy loading 效果时,才会使用静态内部类。如果涉及到反序列化创建对象时,可以尝试使用枚举方式。如果有其他特殊的需求,可以考虑使用双检锁方式。
1.4.1 饿汉式
是否 Lazy 初始化:否
实现难度:易
描述:这种方式比较常用,但容易产生垃圾对象。
优点:没有加锁,执行效率会提高。
缺点:类加载时就初始化,浪费内存。
public class HungryMan {
// 1.构造器私有化
private HungryMan(){}
// 2.提供一个自身的静态私有成员变量
private static final HungryMan hungryMan = new HungryMan();
// 3.提供一个公有的静态工厂方法
public static HungryMan getInstance() {
return hungryMan;
}
}
1.4.2 懒汉式
是否 Lazy 初始化:是
是否多线程安全:否
实现难度:易
描述:这种方式是最基本的实现方式,这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized,所以严格意义上它并不算单例模式。这种方式 lazy loading 很明显,不要求线程安全,在多线程不能正常工作。
public class Idler {
// 1.构造器私有化
private Idler(){}
// 2.提供一个自身的静态私有成员变量
private static Idler idler;
// 3.提供一个公有的静态工厂方法
public static Idler getInstance() {
if (idler == null) {
idler = new Idler();
}
return idler;
}
}
1.4.3 双检锁/双重校验锁(DCL,即 double-checked locking)
JDK 版本:JDK1.5 起
是否 Lazy 初始化:是
是否多线程安全:是
实现难度:较复杂
描述:这种方式采用双锁机制,安全且在多线程情况下能保持高性能。
public class Girl {
// 1.构造器私有化
private Girl() {}
// 2.提供一个自身的静态私有成员变量
private static volatile Girl girl;
// 3.提供一个公有的静态工厂方法
public static Girl getInstance() {
if (girl == null) {
synchronized (Girl.class){
if (girl == null) {
girl = new Girl();
}
}
}
return girl;
}
}
此方式的关键一个点就在于volatile
关键字,其阻止了虚拟机指令重排,使得我们的双检查得以实现。在Java5之前,这种双重检查的方式即使加上了volatile
也没有用,还是不能用,因为JVM有bug。
1.4.4 登记式/静态内部类
是否 Lazy 初始化:是
是否多线程安全:是
实现难度:一般
描述:这种方式能达到双检锁方式一样的功效,但实现更简单。对静态域使用延迟初始化,应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况,双检锁方式可在实例域需要延迟初始化时使用。
public class Boss {
// 1.构造器私有化
private Boss(){}
// 2.静态内部类
private static class BossInstance{
private static final Boss INSTANCE = new Boss();
}
// 3.提供一个公有的静态工厂方法
public static Boss getInstance(){
return BossInstance.INSTANCE;
}
}
1.4.5 枚举
JDK 版本:JDK1.5 起
是否 Lazy 初始化:否
是否多线程安全:是
实现难度:易
描述:这种实现方式还没有被广泛采用,但这是实现单例模式的最佳方法。它更简洁,自动支持序列化机制,绝对防止多次实例化。
这种方式是 Effective Java 作者 Josh Bloch 提倡的方式,它不仅能避免多线程同步问题,而且还自动支持序列化机制,防止反序列化重新创建新的对象,绝对防止多次实例化。不过,由于 JDK1.5 之后才加入 enum 特性,用这种方式写不免让人感觉生疏,在实际工作中,也很少用。
public enum Singleton {
INSTANCE;
public void whateverMethod() {
}
}
1.5 什么情况下的单例对象会被破坏?
- 单例模式的定义:在指定区间范围内只有一个实例,并且提供一个全局访问点。
- 单例模式被破坏的四个场景:
多线程破坏单例
、克隆破坏单例
、反序列化破坏单例
、反射破坏单例
。
-
多线程破化单例:在多线程环境下,线程的时间片是由 CPU 自由分配的,具有随机性,而单例对象作为共享资源可能会同时被多个线程同时操作,从而导致同时创建多个对象。当然,这种情况只出现在懒汉式单例中。如果是饿汉式单例,在线程启动前就被初始化了,不存在线程再创建对象的情况。
- 解决方案: 改为 DCL 双重检查锁的写法、使用静态内部类的写法,性能更高。
-
克隆破坏单例:在 Java 中,所有的类就继承自 Object,也就是说所有的类都实现了 clone()方法。如果是深 clone(),每次都会重新创建新的实例。
- 解决方案:在单例对象中重写 clone() 方法,将单例自身的引用作为返回值。
-
反序列化破坏单例:Java 对象序列化以后,对象通常会被持久化到磁盘或者数据库。如果我们要再次加载到内存,就需要将持久化的内容反序列化成 Java 对象。反序列化是基于字节码来操作的,我们要序列化以前的内容进行反序列化到内存,就需要重新分配内存,也就是说,要重新创建对象。
- 解决方案:在反序列的过程中,Java API 会调用 readResolve()方法,可以通过获取 readResolve()方法的返回值覆盖反序列化创建的对象。
-
反射破坏单例:Java 中的反射机制是可以拿到对象的私有的构造方法,也就是说,反射可以任意调用私有构造方法创建单例对象。
- 解决方案:将单例的实现方式改为枚举式单例,因为在 JDK 源码层面规定了,不允许反射访问枚举。
参考博客: