考虑这样一个需求，我们有两个业务 A 和 B，他们共同使用一个硬盘缓存 DiskCache 的实现。由于在单个业务内只需要一份缓存，这很容易让我们想到单例模式。在本篇文章中，我们从最简单的传统的单例模式的实现开始，一步步实现一个优雅高效的多实例的单例模式。
首先我们看最简单情况——使用 double-check 实现单例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| public class DiskCache {
private static volatile DiskCache sInstance;
private int mMaxSize;
public static DiskCache getInstance() {
if (sInstance == null) {
synchronized (DiskCache.class) {
if (sInstance == null) {
sInstance = new DiskCache();
}
}
}
return sInstance;
}
private DiskCache() {
mMaxSize = 2 * 1024 * 1024;
}
}
|
为了便于后面进行更深入的讨论，这里需要强调一下 volatile 的作用。虚拟机执行 sInstance = new DiskCache() 这一行代码时，做了下面几件事：
- 为对象分配内存
- 初始化对象。也就是给
mMaxSize 赋值，设置 Class 指针等
- 把对象的引用写到变量
sInstance 上
Java 的语言规范要求，任何线程如果读取到针对 volatile 变量的写操作的结果，那么这个写操作前的任何操作，都发生在这个读操作之前（happens-before 关系）。在我们的例子里，任何线程如果读到 sInstance 的值不为 null，DiskCache 的构造函数一定已经执行完成。
如果没有 volatile，某个线程可能会拿到一个 sInstance，但 sInstance.mMaxSize 为 0 或者任意数值。
现在我们考虑多个实例的情况。为了支持多个实例，我们把 sInstance 的类型改成 DiskCache[] 并定义几个常量代表相关的业务：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| public class DiskCache {
public static final int CLIENT0 = 0;
public static final int CLIENT1 = 1;
public static final int CLIENT2 = 2;
public static final int CLIENT_COUNT = 3;
private static volatile DiskCache[] sInstances;
private int mMaxSize;
public static DiskCache getInstance(int client) {
if (sInstances == null || sInstances[client] == null) {
synchronized (DiskCache.class) {
}
}
return sInstances[client];
}
private DiskCache() {
mMaxSize = 2 * 1024 * 1024;
}
}
|
这个时候我犯难了，我们需要保证 synchronized 块里面执行初始化操作后，sInstances[client] 对其他线程是可见的并且对应对象的构造函数已经执行完成。
一个比较天真的实现可能像下面这样：
1
2
3
4
5
6
7
8
9
10
11
| public static DiskCache getInstance(int client) {
if (sInstances == null || sInstances[client] == null) {
synchronized (DiskCache.class) {
if (sInstances == null) {
sInstances = new DiskCache[CLIENT_COUNT];
}
sInstances[client] = new DiskCache();
}
}
return sInstances[client];
}
|
但我必须告诉大家，虽然 sInstances 是一个 volatile 变量，但我们对数组的内容的写操作并不会有任何的同步效果。
由此我们可能会想，能不能给每个实例一个 volatile 变量？当然可以！
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
34
35
36
37
38
39
40
41
42
43
44
| public class DiskCache {
public static final int CLIENT0 = 0;
public static final int CLIENT1 = 1;
public static final int CLIENT2 = 2;
private static volatile DiskCache sInstance0;
private static volatile DiskCache sInstance1;
private static volatile DiskCache sInstance2;
public static DiskCache getInstance(int client) {
switch (client) {
case CLIENT0:
if (sInstance0 == null) {
synchronized (DiskCache.class) {
if (sInstance0 == null) {
sInstance0 = new DiskCache();
}
}
}
return sInstance0;
case CLIENT1:
if (sInstance1 == null) {
synchronized (DiskCache.class) {
if (sInstance1 == null) {
sInstance1 = new DiskCache();
}
}
}
return sInstance2;
case CLIENT2:
if (sInstance2 == null) {
synchronized (DiskCache.class) {
if (sInstance2 == null) {
sInstance2 = new DiskCache();
}
}
}
return sInstance2;
default:
throw new IllegalArgumentException("Unknown client " + client);
}
}
}
|
我可以很负责任地说，这段代码是正确的，并且他的运行效率很不错，就是难看了些，扩展性也不好。这意味着，我们还得回到使用数组的那个方法去。
回想一下前面我们关于 volatile happens-before 关系的论述，结合那个失败的基于数组的实现，我在想，是否有一种方式，让我们在把一个新创建的对象放到数组中后，再来写某个 volatile 变量；同时，在进入 synchronized 块之前，我们通过检查这个变量，来判断数组中对应的实例是否已经初始化。另外，由于我们只能写一个变量，位掩码也自然而然浮了出来。结合这几个点子，我们可以按下面这种方式来实现多实例的单例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| public class DiskCache {
public static final int CLIENT0 = 0;
public static final int CLIENT1 = 1;
public static final int CLIENT2 = 2;
private static final int CLIENT_COUNT = 3;
private static final DiskCache[] sInstances = new DiskCache[CLIENT_COUNT];
private static volatile int sInstanceMask;
public static DiskCache getInstance(int client) {
int mask = 1 << client;
if ((sInstanceMask & mask) == 0) {
synchronized (DiskCache.class) {
if ((sInstanceMask & mask) == 0) {
sInstances[client] = new DiskCache();
sInstanceMask |= mask;
}
}
}
return sInstances[client];
}
}
|
在这个实现中，如果客户读到了对应的位为 1，那么 DiskCache 一定是已经初始化完成，并且已经写到了数组里。需要注意的是，这里最多只支持 32 个实例。