单列模式处理并发的4种方式

背景
众所周知，单例模式主要就是将构造函数声明为private，来防止外部调用实例化。代码如下：

public class Singleton {
private static Singleton uniqueInstance;

private Singleton() {}

public static Singleton getInstance() {
if (uniqueInstance == null) {
uniqueInstance = new Singleton();
}
return uniqueInstance;
}
1
2
3
4
5
6
7
8
}
这段逻辑，在单线程的程序中工作得很好。但是，当引入多线程时，就可能会出现问题。

示意图如下：

示意图
那么该如何解决呢
1.加上同步锁
使用synchroinzed关键字，使程序在执行时，同一时刻，只有一个线程执行getInstance方法。

public class Singleton {
private static Singleton uniqueInstance;

private Singleton() {}

public static synchronized Singleton getInstance() {
if (uniqueInstance == null) {
uniqueInstance = new Singleton();
}
return uniqueInstance;
}
1
2
3
4
5
6
7
8
}
适用场景：
getInstance的性能对应用程序不是关键。因为这种方法会严重降低性能，而且只有第一次执行getInstance方法的时候，才需要同步。之后所有执行此方法时，都不需要同步锁了。(个人觉得，用了synchronized后，只有在未初始化的时候，性能影响会比较大。之后所有执行次方法，只是直接返回实例了，所以对性能影响有限)

2.使用饿汉模式
在应用程序声明这个类的时候，就执行实例化。

public class Singleton {
private static Singleton uniqueInstance = new Singleton();

private Singleton() {}

public static Singleton getInstance() {
return uniqueInstance;
}
1
2
3
4
5
}
适用场景：
如果应用程序总是创建并使用单例模式，或者在创建和运行时方面的负担不太繁重。它是最简单、最清楚的替代方法。

静态初始化器如何保证实例只会被创建一次？
刚开始，我以为静态方法在程序启动时，会加载所有类的静态初始化器，从而保证实例只会有一个。

public class Singleton {
private static Singleton uniqueInstance = new Singleton();

private Singleton() {
System.out.println(“create ins”);
}

public static Singleton getInstance() {
return uniqueInstance;
}
1
2
3
4
5
6
7
}
public class Main {

public static void main(String[] args) {
System.out.println(“main”);
Singleton.getInstance();
}
1
2
3
4
}
这段程序实际的执行结果却是：
main
create ins
原来，静态初始化器是保证线程安全的。在每次加载类的时候才会去执行静态初始化器。一个类只会被加载一次，如果一个类被加载了两次，运行时类名就会冲突了。所以jvm会保证静态初始化器是线程安全的。

3.双重检查加锁
首先检查是否实例已经创建了，如果尚未创建，才进行同步。这样一来，只有第一次会同步。

public class Singleton {
private volatile static Singleton uniqueInstance;

private Singleton() {}

public static Singleton getInstance() {
if (uniqueInstance == null) {
synchronized (Singleton.class) {
if (uniqueInstance == null) {
uniqueInstance = new Singleton();
}
}
}
return uniqueInstance;
}
1
2
3
4
5
6
7
8
9
10
11
12
}
Volatile
Volatile是轻量级的synchronized，它在多处理器开发中保证了共享变量的“可见性”。可见性的意思是当一个线程修改一个共享变量时，另外一个线程能读到这个修改的值。

适用场景：
java 5及以后的版本才支持。如果性能死你关心的重点，可以使用这种方法。实例域推荐使用这种方法，静态域推荐使用第4种方法。

4.lazy initialization holder class
public class Singleton {
private static class SingletonHolder {
static final Singleton singleton = new Singleton();
}

public static Singleton getInstance() {
return SingletonHolder.singleton;
}
1
2
3
}
适用场景：
处于性能的考虑而需要对静态域使用延迟初始化