在面试中相信很多人会被问到:说说你最了解的三个设计模式,日常开发中使用过哪些设计模式等等。最近几篇文章就来学习一下设计模式,这是第一篇文章,也是最常见的模式——单例模式。
什么是单例
单例模式(Singleton Pattern
),顾名思义,即保证一个类仅有一个实例,并在全局中提供一个访问点。
在实现单例时,要保证一个类仅有一个实例,就不能提供公有的构造方法,任由其他类创建实例,对应变量也需要为 static
,只在加载时初始化一次。另外呢,要在全局中都能访问到,还需要提供一个静态的公有方法来进行访问。
具体实现方式比较多,对于不同的场景,也应该选择不同的方式,例如是否需要保证线程安全,是否需要延迟加载。下面具体来看一下。
饿汉式(线程安全)
根据上面对单例模式实现的说明,可以很容易地想到如下实现:
public class Singleton1 {
private static Singleton1 instance = new Singleton1();
private Singleton1() { }
public static Singleton1 getInstance() {
return instance;
}
}
这种方式在该类第一次被加载时,就会创建好该实例。这就是所谓的饿汉式,也就是,在想要使用实例时,立刻就能拿到,而不需要进行等待。
另外这种方式,由 JVM
保证其线程安全。但是这种方式可能会造成资源消耗,因为有可能这个实例根本就用不到,而进行不必要的加载。
懒汉式(非线程安全)
上述方式在类加载时就进行实例化,可能会造成不必要的加载。那么我们可以在其真正被访问的时候,再进行实例化,于是可以写出如下方式:
public class Singleton2 {
private static Singleton2 instance;
private Singleton2() { }
public static Singleton2 getInstance() {
if (instance == null) {
instance = new Singleton2();
}
return instance;
}
}
在 getInstance
方法中,第一次访问时,由于没有初始化,才去进行进行初始化,在后续访问时,直接返回该实例即可。这就是所谓的懒汉式,也就是,它不会提前把实例创建出来,而是将其延迟到第一次被访问的时候。
但是懒汉式存在线程安全问题,如下图:
在多线程场景下,如果有两个线程同时进入 if
语句中,则这两个线程分别创建了一个对象,在两个线程从 if
中退出时,就创建了两个不一样的对象。
懒汉式(线程安全)
既然普通的懒汉式会出现线程安全问题,那么给创建对象的方法加锁即可:
public class Singleton3 {
private static Singleton3 instance;
private Singleton3() { }
public static synchronized Singleton3 getInstance() {
if (instance == null) {
instance = new Singleton3();
}
return instance;
}
}
上述这种做法虽然在多线程场景下也能正常工作,也具备延迟加载。但由于 synchronized
方法锁住了整个方法,效率比较低。于是,聪明的小伙伴,可以很容易想到,使用同步方法块,来减小加锁的粒度。
看下面两种做法,加锁粒度确实减小了,但是它们却并不能保证线程安全:
synchronized (Singleton4.class) {
if (instance == null) {
instance = new Singleton4();
}
}
由于指定重排序出现问题,后面介绍双重校验锁时会详细说。
if (instance == null) {
synchronized (Singleton4.class) {
instance = new Singleton4();
}
}
如果 synchronized
加在 if
语句外面,这和普通的懒汉式做法一样,没有区别。如果有两个线程分别进入 if
语句,虽然也有加锁操作,但是两个线程都会执行实例化,也就是会进行两次实例化。
双重校验锁(线程安全)
于是引出了双重校验锁方式,可以先判断对象是否实例化,如果没有再进行加锁,再加锁之后,再次判断是否实例化,如果仍然没有实例化,才实例化对象。
这种做法的完整代码如下:
public class Singleton5 {
private static volatile Singleton5 instance;
private Singleton5() { }
public static Singleton5 getInstance() {
// 如果已经实例化,则直接返回,不用加锁,提升性能
if (instance == null) {
synchronized (Singleton5.class) {
// 再次检查,保证线程安全
if (instance == null) {
instance = new Singleton5();
}
}
}
return instance;
}
}
可以看到,在 synchronized
语句前后,有两个 if
判断,这就是所谓的双重校验锁。
使用 volatile
其实,如果仅仅是双重校验的话,仍然不能保证线程安全问题。这就要分析 instance = new Singleton5();
这段代码。
虽然代码只有一句,但在 JVM
中它其实被分为三步执行:
- 为
instance
分配内存空间; - 对
instance
进行初始化; - 将
instance
指向分配的内存地址;
但由于编译器或处理器可能会对指令重排序,执行的顺序就有可能变成 1->3->2
。这在单线程环境下不会出现问题,但是在多线程环境下可能会导致一个线程获得还没有初始化的实例。
例如,线程 A
执行了第 1
、3
步后,此时线程 B
调用 getInstance()
方法,判断 instance
不为空,因此返回 instance
。但此时 instance
还未被初始化。
所以,就需要使用 volatile
关键字来修饰 instance
,禁止编译器的指令重排序,保证在多线程环境下也能正常运行。
静态内部类式(线程安全)
目前双重校验锁的做法看起来不错,使用延迟加载,在保证线程安全的同时,加锁粒度也比较小,效率还不错。那还有没有其他方法呢?
那就是使用静态内部类来实现,来看一下它的实现:
public class Singleton6 {
private Singleton6() { }
private static class InnerSingleton {
private static final Singleton6 INSTANCE = new Singleton6();
}
public static Singleton6 getInstance() {
return InnerSingleton.INSTANCE;
}
}
在这种实现中,当外部类 Singleton6
类被加载时,静态内部类 InnerSingleton
并没有被加载。
而是只有当调用 getInstance
方法,从而访问类的静态变量时,才会加载内部类,从而实例化 INSTANCE
。并且 JVM
能确保 INSTANCE
只能被实例化一次,即它也是线程安全的。
枚举式(线程安全)
另外,使用枚举实现单例也是一种不错的方式,代码非常简单:
public enum Singleton6 {
INSTANCE();
Singleton6() { }
}
枚举的实现中,类被定义为 final
,其枚举值被定义为 static
final
,对枚举值的初始化放在静态语句块中。所以,对象在该类第一次被加载时实例化,这不仅避免了线程安全问题,而且也避免了下面提到的反序列化对单例的破坏。
单例与序列化
现在来看一下,对象在序列化和反序列化时,是否还能够保证单例。
这里使用双重校验锁实现的单例类,对 Singleton5
类添加 Serializable
接口,然后进行测试:
public class SingletonTest {
public static void main(String[] args) {
Singleton5 instance1 = Singleton5.getInstance();
try ( ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("tempFile")) ){
oos.writeObject(instance1);
} catch (IOException e) {
e.printStackTrace();
}
Singleton5 instance2 = null;
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("tempFile"))) ){
instance2 = (Singleton5) ois.readObject();
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
System.out.println(instance1 == instance2);
}
}
// false
可以看到,对 Singleton5
进行反序列得到的是一个新的对象,如此就破坏了 Singleton5
的单例性。
我们可以在 Singleton5
类中添加一个 readResolve()
方法,并在该方法中指定要返回的对象的生成策略:
public class Singleton5 implements Serializable {
private static volatile Singleton5 instance;
private Singleton5() { }
public static Singleton5 getInstance() {
if (instance == null) {
synchronized (Singleton5.class) {
if (instance == null) {
instance = new Singleton5();
}
}
}
return instance;
}
// 添加 readResolve 方法
private Object readResolve() {
return instance;
}
}
通过 debug
方法查看源码,在 readObject
方法的调用栈中,可以看到 ObejctStreamClass
类的 invokeReadResolve
方法:
如果定义了 readResolve
方法,会通过反射进行调用,根据指定的策略来生成对象。
有哪些好的单例模式实践
JDK#Runtime
该类用于获取应用运行时的环境。可以看到这是一个饿汉式的单例。
public class Runtime {
private static Runtime currentRuntime = new Runtime();
public static Runtime getRuntime() {
return currentRuntime;
}
private Runtime() {}
}
Spring#Singleton
在 Spring
中定义 Bean
时,可以指定是单例还是多例(默认为单例):
@Scope("singleton")
查看其源码,单例模式实现如下:
public abstract class AbstractFactoryBean<T>
implements FactoryBean<T>, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, DisposableBean {
private T singletonInstance;
@Override
public void afterPropertiesSet() throws Exception {
// 扫描配置时,单例模式
// 就会将 initialized 置为 true
if (isSingleton()) {
this.initialized = true;
// 调用子类方法创建对象
this.singletonInstance = createInstance();
this.earlySingletonInstance = null;
}
}
@Override
public final T getObject() throws Exception {
if (isSingleton()) {
return (this.initialized ? this.singletonInstance : getEarlySingletonInstance());
}
else {
return createInstance();
}
}
}
参考资料
- Hollis:设计模式(二)——单例模式
- CyC2018/CS-Notes:设计模式
- 越努力越幸运-致自己:java设计模式精讲 Debug 方式+内存分析 第8章 单例模式