GoF设计模式(一):Singleton Pattern 单例模式

Singleton Pattern 单例模式,作为创建型模式的一种,其保证了类的实例对象只有一个,并对外提供此唯一实例的访问接口

abstract.jpeg

概述

对于单例模式而言,其最核心的目的就是为了保证该类的实例对象是唯一的。为此一方面,需要将该类的构造函数设为private,另一方面,该类需要在内部完成实例的构造并对外提供访问接口。单例模式的好处显而易见,可以避免频繁创建、销毁实例所带来的性能开销;但其缺点也同样明显,此类不仅需要描述业务逻辑,同时还需要构造出该类的唯一对象并对外提供访问接口,其显然违背了单一职责原则

实现

单例模式的思想虽然简单易懂,但实现起来却可谓是花样繁多、妙不可言。这里来介绍几种常见的单例模式的实现

饿汉式

如下实现最为简单,当 SingletonDemo1 类被加载到JVM中,即会完成实例化。即不是所谓的Lazy Load 延迟加载,故通常被称之为 “饿汉式” 单例。其最大的问题就在,可能构造出来的实例对象从头到尾没有被使用过(没有调用过getInstance方法),从而浪费内存。可能有人会对此有些困惑,SingletonDemo1 类被加载到JVM中了,那肯定是因为调用了getInstance方法啊。难道还有别的原因?答案是肯定的

这里,我们先简要补充一些类加载机制的相关知识点。我们知道Java中的类被加载到JVM中,通常会有如下几个阶段:加载、 验证、准备、解析、初始化等。其中对于初始化阶段而言,虚拟机规范严格规定了有且仅有以下5种情况必须立即对类进行初始化(而加载、 验证、准备显然必须在此之前开始):

  1. 遇到new、getstatic、putstatic或invokestatic类型的字节码指令时,在Java代码层面上就是new对象、读取或设置类的静态变量(被final修饰、已在编译期将结果放入常量池的静态变量除外)、调用类的静态方法
  2. 对该类使用反射
  3. 当初始化一个类的时候,如果发现其父类还未初始化,则需要先初始化父类
  4. 当JVM启动时,虚拟机会先初始化开发者所指定的主类(即main方法所在类)
  5. 当使用JDK 1.7的动态语言支持时,如果一个java.lang.invoke.MethodHandle实例最后解析的结果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄,且该方法句柄所对应的类没有进行过初始化,则需要先触发其初始化

说到这里,大家可能就明白了,如果SingletonDemo1类中还有其他静态方法,一旦被调用就会导致SingletonDemo1类被加载、初始化,此时即完成了实例的构造。众所周知,JVM保证了类加载过程的线程安全,所以饿汉式单例同样是线程安全的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/**
* 单例模式1,饿汉式
*/
public class SingletonDemo1 {
private static SingletonDemo1 instance = new SingletonDemo1("我是饿汉式的单例");

private String description;

/**
* 私有构造器
* @param description
*/
private SingletonDemo1(String description) {
this.description = description;
}

public void getInfo() {
System.out.println(description);
}

/**
* 提供实例的访问接口
* @return
*/
public static SingletonDemo1 getInstance() {
return instance;
}

public static void main(String[] args) {
SingletonDemo1 singletonDemo1 = SingletonDemo1.getInstance();
singletonDemo1.getInfo();
}
}

测试结果如下所示

figure 1.jpeg

懒汉式

前面说到,饿汉式单例会导致内存空间的浪费,那么有没有办法解决这个问题呢?答案是有的,这就是”懒汉式”单例。顾名思义,其实例不是在类加载、初始化时被构建的,而是在真正需要的时候才去创建,如下所示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/**
* 单例模式2,线程不安全的懒汉式
*/
public class SingletonDemo2 {
private static SingletonDemo2 instance = null;
private String description;

private SingletonDemo2(String description) {
this.description = description;
}

public void getInfo() {
System.out.println(description);
}

public static SingletonDemo2 getInstance() {
if( instance==null ) {
instance = new SingletonDemo2("我是线程不安全的懒汉式单例");
}
return instance;
}

public static void main(String[] args) {
SingletonDemo2 singletonDemo2 = SingletonDemo2.getInstance();
singletonDemo2.getInfo();
}

}

测试结果如下所示

figure 2.png

“懒汉式”单例虽然实现了Lazy Load延迟加载,但是其存在一个很严重的问题,不是线程安全的。所以如果在多线程环境下,我们需要使用下面线程安全的”懒汉式”单例,其保障线程安全的手段也很简单,直接使用synchronized来修饰getInstance方法。这种办法过于简单粗暴,同时会导致效率十分低下。实例一旦被构造完毕后,由于锁的存在,导致每次只能由一个线程可以获取到实例对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/**
* 单例模式3, 线程安全但效率低下的懒汉式
*/
public class SingletonDemo3 {
private static SingletonDemo3 intance = null;
private String description;

private SingletonDemo3(String description) {
this.description = description;
}

public void getInfo() {
System.out.printf(description);
}

public static synchronized SingletonDemo3 getInstance() {
if( intance==null ) {
intance = new SingletonDemo3("我是线程安全线程安全但效率低下的懒汉式单例");
}
return intance;
}

public static void main(String[] args) {
SingletonDemo3 singletonDemo3 = SingletonDemo3.getInstance();
singletonDemo3.getInfo();
}
}

测试结果如下所示

figure 3.jpeg

基于DCL(Double-Checked Locking)双重检查锁的单例

通过前面我们看到,无论是饿汉式单例还是懒汉式单例,其都有明显的缺点。那么有没有一种完美的单例?既可以实现Lazy Load延迟加载,又可以在保证线程安全的前提下依然具备较高的效率呢。答案是肯定——基于DCL(Double-Checked Locking)双重检查锁的单例。其实现如下,该单例实现中进行了两次检查。第一次检查时如果发现实例已经构造完毕了,则无需加锁直接返回实例对象即可。其保证了实例在构建完成后,其他多个线程可以同时快速获取该实例。第二次检查时则是为了避免重复构造实例,因为在还未构造实例前,可能会有多个线程通过了第一次检查,准备加锁来构造实例。在DCL的单例实现中,尤其需要注意的一点是静态变量instance必须要使用volatile进行修饰。其原因在于volatile禁止了指令的重排序。这里就此问题再作一些详细的解释说明:在JDK1.5之前的Java内存模型中,虽然不允许volatile变量之间进行重排序,但却允许普通变量与volatile变量之间的重排序。所以在JSR 133(JDK 1.5)中对volatile变量的内存语义进一步增强,即限制了普通变量与volatile变量之间是否可以重排序的具体场景。这也是为什么在JDK 1.5之前无法通过DCL实现一个线程安全的单例模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/**
* 单例模式4,基于DCL的线程安全的单例
*/
public class SingletonDemo4 {
// 此处必须要使用volatile修饰!
private static volatile SingletonDemo4 instance = null;
private String description;

private SingletonDemo4(String description) {
this.description = description;
}

public void getInfo() {
System.out.println(description);
}

public static SingletonDemo4 getInstance() {
if( instance==null ) { // 第一次检查:如果实例已经构造完成则直接取,避免每次取之前需要获取锁
synchronized (SingletonDemo4.class) {
if(instance==null) { // 第二次检查:避免构造出多个实例
instance = new SingletonDemo4("我是基于DCL的线程安全的单例");
}
}
}
return instance;
}

public static void main(String[] args) {
SingletonDemo4 singletonDemo4 = SingletonDemo4.getInstance();
singletonDemo4.getInfo();
}

}

测试结果如下

figure 4.jpeg

基于静态内部类的单例

前面我们说到的第一种单例实现,之所以被称为饿汉式、非延迟加载。其原因就在于类的加载、初始化不能100%保证是因为调用getInstance方法引起的。而这里我们通过静态内部类的方式来实现一个延迟加载的单例,代码如下所示。当调用外部类SingletonDemo5的一些静态方法(当然getInstance方法除外),只会加载、初始化外部类SingletonDemo5,而不会去初始化静态内部类SingletonDemo5Holder。只有通过调用getInstance方法访问了静态内部类SingletonDemo5Holder的静态变量instance,静态内部类SingletonDemo5Holder才会被加载、初始化,显然此时实例才会被真正的构造。所以对于基于静态内部类的单例实现而言,其之所以能保证Lazy Load延迟加载特性,是其因为通过SingletonDemo5Holder静态内部类100%保证了静态内部类被加载、初始化是因为调用外部类的getInstance方法而导致的。同样地,该方式的单例也是满足线程安全的,原因在饿汉式单例实现中已作解释,此处就不再赘述

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/**
* 单例模式5,静态内部类
*/
public class SingletonDemo5 {
private String description;

private SingletonDemo5(String description) {
this.description = description;
}

public void getInfo() {
System.out.println(description);
}

private static class SingletonDemo5Holder{
private static final SingletonDemo5 instance = new SingletonDemo5("我是基于静态内部类的线程安全的单例");
}

public static SingletonDemo5 getInstance() {
return SingletonDemo5Holder.instance;
}

public static void main(String[] args) {
SingletonDemo5 singletonDemo5 = SingletonDemo5.getInstance();
singletonDemo5.getInfo();
}
}

测试结果如下所示

figure 5.jpeg

基于枚举的单例

对于Java的枚举类型而言,其构造器是且只能是private私有的。故其特别适合用于实现单例模式。下面即是一个基于枚举的单例实现,可以看到此种实现非常简洁优雅。当枚举类进行加载、初始化时,即会完成实例的构建,我们通过枚举的特性保证了实例的唯一性,当然其不是Lazy Load延迟加载的。与此同时根据类的加载机制我们可知其也是线程安全的(由JVM保证)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/**
* 单例模式6,枚举法
*/
public enum SingletonDemo6 {
INSTANCE("我是枚举法的单例");

private String description;

/**
* 枚举的构造器默认访问权限是private, 当然也只能是私有的
* @param description
*/
SingletonDemo6(String description) {
this.description = description;
}

public void getInfo() {
System.out.println(description);
}
}
...
/**
* 测试用例
*/
public class SingletonDemo6Test {
public static void main(String[] args) {
SingletonDemo6 singletonDemo6 = SingletonDemo6.INSTANCE;
singletonDemo6.getInfo();
}
}

测试结果如下

figure 6.png

参考文献

  1. Head First 设计模式 弗里曼著
0%