0x00.单例模式的定义

单例模式确保某个类只有一个实例,而且自行实例化并向整个系统提供这个实例。

0x01.单例模式的特点

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

0x02.单例模式的应用

在计算机系统中,线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。

这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机,但只能有一个Printer Spooler,以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口,系统应当集中管理这些通信端口,以避免一个通信端口同时被两个请求同时调用。总之,选择单例模式就是为了避免不一致状态。

0x03.单例模式的Java代码

单例模式分为懒汉式(需要才去创建对象)和饿汉式(创建类的实例时就去创建对象)。

0x04.饿汉式

属性实例化对象

1
2
3
4
5
6
7
8
9
10
11
12
13
//饿汉模式:线程安全,耗费资源。
public class HugerSingletonTest {
//该对象的引用不可修改
private static final HugerSingletonTest ourInstance = new HugerSingletonTest();


public static HugerSingletonTest getInstance() {
return ourInstance;
}

private HugerSingletonTest() {}

}

在静态代码块实例对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Singleton {
private static Singleton ourInstance;

static {
ourInstance = new Singleton();
}

public static Singleton getInstance() {
return ourInstance;
}

private Singleton() {}

}

分析:饿汉式单例模式只要调用了该类,就会实例化一个对象,但有时我们并只需要调用该类中的一个方法,而不需要实例化一个对象,所以饿汉式是比较消耗资源的。

0x05.懒汉式

非线程安全

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Singleton {
private static Singleton ourInstance;


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

private Singleton() {}

}

分析:如果有两个线程同时调用getInstance()方法,则会创建两个实例化对象。所以是非线程安全的。

线程安全:给方法加锁

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Singleton {
private static Singleton ourInstance;


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

private Singleton() {}

}

分析:如果有多个线程调用getInstance()方法,当一个线程获取该方法,而其它线程必须等待,消耗资源。

线程安全:双重检查锁(同步代码块)

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

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

private Singleton() {}
}

分析:为什么需要双重检查锁呢?因为第一次检查是确保之前是一个空对象,而非空对象就不需要同步了,空对象的线程然后进入同步代码块,如果不加第二次空对象检查,两个线程同时获取同步代码块,一个线程进入同步代码块,另一个线程就会等待,而这两个线程就会创建两个实例化对象,所以需要在线程进入同步代码块后再次进行空对象检查,才能确保只创建一个实例化对象。

线程安全:静态内部类

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Singleton {
private static class SingletonHodler {
private static final Singleton ourInstance = new Singleton();
}


public static Singleton getInstance() {
return SingletonHodler.ourInstance;
}

private Singleton() {}

}

分析:利用静态内部类,某个线程在调用该方法时会创建一个实例化对象。

线程安全:枚举

1
2
3
4
5
6
enum SingletonTest {  
INSTANCE;
public void whateverMethod() {

}
}

分析:枚举的方式是《Effective Java》书中提倡的方式,它不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象,但是在枚举中的其他任何方法的线程安全由程序员自己负责。还有防止上面的通过反射机制调用私用构造器。不过,由于Java1.5中才加入enum特性,所以使用的人并不多。

线程安全:使用ThreadLocal

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Singleton {
private static final ThreadLocal<Singleton> tlSingleton =
new ThreadLocal<Singleton>() {
@Override
protected Singleton initialValue() {
return new Singleton();
}
};

public static Singleton getInstance() {
return tlSingleton.get();
}

private Singleton() {}

}

分析:ThreadLocal会为每一个线程提供一个独立的变量副本,从而隔离了多个线程对数据的访问冲突。对于多线程资源共享的问题,同步机制采用了“以时间换空间”的方式,而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量,让不同的线程排队访问,而后者为每一个线程都提供了一份变量,因此可以同时访问而互不影响。

线程安全:CAS锁

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Singleton {
private static final AtomicReference<Singleton> INSTANCE = new AtomicReference<>();

/**
* 用CAS确保线程安全
*/
public static Singleton getInstance() {
while (true) {
Singleton current = INSTANCE.get();
if (current != null) {
return current;
}
current = new Singleton();
if (INSTANCE.compareAndSet(null, current)) {
return current;
}
}
}

private Singleton() {}

}

0x06.指令重排序

我们再来思考一个问题,就是懒汉式的双重检查版本的单例模式,它一定是线程安全的吗?我会毫不犹豫的告诉你—不一定,因为在JVM的编译过程中会存在指令重排序的问题。

其实创建一个对象,往往包含三个过程。
对于singleton = new Singleton(),这不是一个原子操作,在 JVM 中包含的三个过程。

1>给 singleton 分配内存

2>调用 Singleton 的构造函数来初始化成员变量,形成实例

3>将singleton对象指向分配的内存空间(执行完这步 singleton才是非 null 了)

但是,由于JVM会进行指令重排序,所以上面的第二步和第三步的顺序是不能保证的,最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是 1-3-2,则在 3 执行完毕、2 未执行之前,被l另一个线程抢占了,这时 instance 已经是非 null 了(但却没有初始化),所以这个线程会直接返回 instance,然后使用,那肯定就会报错了。

针对这种情况,我们有什么解决方法呢?那就是把singleton声明成 volatile ,改进后的懒汉式线程安全(双重检查锁)的代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Singleton {
//volatile的作用是:保证可见性、禁止指令重排序,但不能保证原子性
private volatile static Singleton ourInstance;

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

private Singleton() {
}

}

0x07.单例模式在JDK8源码中的使用

当然JDK源码中使用了大量的设计模式,那哪些地方使用了单例设计模式呢?

Runtime类部分源码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//饿汉式单例设计模式
public class Runtime {
private static Runtime currentRuntime = new Runtime();

public static Runtime getRuntime() {
return currentRuntime;
}

private Runtime() {
}

//省略很多行

}