单例模式

Updated on 2020.03.25

一、概述

1.1 什么是单例模式?

这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象

注意:

                  ✵   单例类 只能有一个实例。
                  ✵   单例类 必须自己创建自己的唯一实例。
                  ✵   单例类 必须给所有其他对象提供这一实例。

1.2 单例 DEMO

我们看个简单的 “单例设计” 的 Demo,先创建一个 Singleton 类:SingleObject.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class SingleObject {

//创建 SingleObject 的一个对象
private static SingleObject instance = new SingleObject();

// 让构造函数为 private,这样该类就不会被实例化
private SingleObject(){}

// 获取唯一可用的对象
public static SingleObject getInstance(){
return instance;
}

public void showMessage(){
System.out.println("Hello World!");
}
}

然后从 Singleton 类获取唯一的对象:SingletonPatternDemo.java

1
2
3
4
5
6
7
8
9
10
11
12
13
public class SingletonPatternDemo {
public static void main(String[] args) {

// 不合法的构造函数,编译时错误:构造函数 SingleObject() 是不可见的
//SingleObject object = new SingleObject();

// 获取唯一可用的对象
SingleObject object = SingleObject.getInstance();

// 显示消息
object.showMessage();
}
}

我们看下执行结果:

1
Hello World!

2. 单例模式的实现方式

2.1 基本版:饿汉式

代码范例

1
2
3
4
5
6
7
8
9
public class Singleton {  

private static Singleton instance = new Singleton(); // 类加载时就初始化
private Singleton (){}

public static Singleton getInstance() {
return instance;
}
}

方法说明

这种方式比较常见,典型的 “饿汉式” 写法。

是否多线程安全
实现难度
优点 没有加锁,执行效率会提高
缺点 类加载时就初始化,浪费内存

2.2 改进版:懒汉式 - 线程不安全

代码范例

1
2
3
4
5
6
7
8
9
10
11
12
public class Singleton {  

private static Singleton instance; // 类加载时不作初始化
private Singleton (){}

public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}

方法说明

这种方式是大多数面试者的写法,也是教科书上的标配,但这段代码却存在一个致命的问题:当多个线程并行调用 getInstance() 的时候,就会创建多个实例。

2.3 改进版:懒汉式 - 线程安全

代码范例

1
2
3
4
5
6
7
8
9
10
11
12
public class Singleton {  

private static Singleton instance;
private Singleton (){}

public static synchronized Singleton getInstance() { // 加锁
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}

方法说明

既然要线程安全,那就如上所述“加锁”处理!

是否多线程安全
实现难度
优点 第一次调用才初始化,避免内存浪费
缺点 必须加锁 synchronized 才能保证单例,但加锁会影响效率(加锁操作也是耗时的)

2.4 改进版:双重校验锁

代码范例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Singleton {  

private static Singleton instance;
private Singleton (){}

public static Singleton getSingleton() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}

方法说明

为什么需要进行 2 次判断是否为空呢?

第一次判断是为了避免不必要的同步,第二次判断是确保在此之前没有其他进程进入到 synchronized 块创建了新实例。

这段代码看起来很完美,很可惜,它还是有隐患!

主要在于 instance = new Singleton() 这句,这并非是一个原子操作,事实上在 JVM 中这句话大概做了下面 3 件事情:

      ✵ 1、给 instance 分配内存
      ✵ 2、调用 Singleton 的构造函数来初始化成员变量
      ✵ 3、将 instance 对象指向分配的内存空间(执行完这步 instance 就为非 null 了)

但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的,最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者,则在 3 执行完毕、2 未执行之前,被线程二抢占了,这时 instance 已经是非 null 了(但却没有初始化),所以线程二会直接返回 instance,然后使用,最后顺理成章地报错。

2.5 改进版:双检锁(volatile)

代码范例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Singleton {  

private volatile static Singleton instance;
private Singleton (){}

public static Singleton getSingleton() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}

方法说明

有些人认为使用 volatile 的原因是可见性,也就是可以保证线程在本地不会存有 instance 的副本,每次都是去主内存中读取。但其实是不对的。

使用 volatile 的主要原因是其另一个特性:禁止指令重排序优化

也就是说,在 volatile 变量的赋值操作后面会有一个内存屏障(生成的汇编代码上),读操作不会被重排序到内存屏障之前。比如上面的例子,取操作必须在执行完 1-2-3 之后或者 1-3-2 之后,不存在执行到 1-3 然后取到值的情况。从「先行发生原则」的角度理解的话,就是对于一个 volatile 变量的写操作都先行发生于后面对这个变量的读操作(这里的“后面”是时间上的先后顺序)。

但是特别注意在 Java 5 以前的版本使用了 volatile 的双检锁还是有问题的。其原因是 Java 5 以前的 JMM (Java 内存模型)是存在缺陷的,即使将变量声明成 volatile 也不能完全避免重排序,主要是 volatile 变量前后的代码仍然存在重排序问题。这个 volatile 屏蔽重排序的问题在 Java 5 中才得以修复,所以在这之后才可以放心使用 volatile。

那么,有没有一种既有懒加载,又保证了线程安全,还简单的方法呢?

当然有,静态内部类就是这么一种我们想要的方法。我们完全可以把 Singleton 实例放在一个静态内部类中,这样就避免了静态实例在 Singleton 类加载的时候就创建对象,并且由于静态内部类只会被加载一次,所以这种写法也是线程安全的。

2.6 终极版:静态内部类

代码范例

1
2
3
4
5
6
7
8
9
10
11
12
    public class Singleton {  

private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}

private Singleton (){}

public static final Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}

方法说明

这是比较推荐的解法,这种写法用 JVM 本身的机制保证了线程安全的问题,同时读取实例的时候也不会进行同步,没什么性能缺陷,还不依赖 JDK 版本。

2.7 传说版:枚举

代码范例

1
2
3
public enum Singleton {  
INSTANCE;
}

方法说明

这是从 Java 1.5 发行版本后就可以实用的单例方法,我们可以通过 Singleton.INSTANCE 来访问实例,这比调用 getInstance() 方法简单多了。

创建枚举默认就是线程安全的,所以不需要担心 double checked locking,而且还能防止反序列化导致重新创建新的对象。