如何在Java中使用双重检查锁实现单例

转载自：http://www.cnblogs.com/whgw/archive/2011/10/15/2213459.html

单例创建模式是一个通用的编程习语。和多线程一起使用时，必需使用某种类型的同步。在努力创建更有效的代码时，Java 程序员们创建了双重检查锁定习语，将其和单例创建模式一起使用，从而限制同步代码量。

单例创建习语

要理解双重检查锁定习语是从哪里起源的，就必须理解通用单例创建习语，如清单 1 中的阐释：

清单
1. 单例创建习语

import java.util.*; class Singleton { private static Singleton instance; private Vector v; private boolean inUse; private Singleton() { v = new Vector(); v.addElement(new Object()); inUse = true; } public static Singleton getInstance() { if (instance == null) //1 instance = new Singleton(); //2 return instance; //3 } }

此类的设计确保只创建一个

Singleton

对象。构造函数被声明为

private

，

getInstance()

方法只创建一个对象。这个实现适合于单线程程序。然而，当引入多线程时，就必须通过同步来保护

getInstance()

方法。如果不保护

getInstance()

方法，则可能返回

Singleton

对象的两个不同的实例。假设两个线程并发调用

getInstance()

方法并且按以下顺序执行调用：

线程 1 调用

getInstance()

方法并决定

instance

在
//1 处为

null

。

线程 1 进入

if

代码块，但在执行 //2 处的代码行时被线程 2 预占。

线程 2 调用

getInstance()

方法并在 //1 处决定

instance

为

null

。

线程 2 进入

if

代码块并创建一个新的

Singleton

对象并在
//2 处将变量

instance

分配给这个新对象。

线程 2 在 //3 处返回

Singleton

对象引用。

线程 2 被线程 1 预占。

线程 1 在它停止的地方启动，并执行 //2 代码行，这导致创建另一个

Singleton

对象。

线程 1 在 //3 处返回这个对象。

结果是

getInstance()

方法创建了两个

Singleton

对象，而它本该只创建一个对象。通过同步

getInstance()

方法从而在同一时间只允许一个线程执行代码，这个问题得以改正，如清单
2 所示：

清单
2. 线程安全的 getInstance() 方法

public static synchronized Singleton getInstance() { if (instance == null) //1 instance = new Singleton(); //2 return instance; //3 }

清单 2 中的代码针对多线程访问

getInstance()

方法运行得很好。然而，当分析这段代码时，您会意识到只有在第一次调用方法时才需要同步。由于只有第一次调用执行了 //2 处的代码，而只有此行代码需要同步，因此就无需对后续调用使用同步。所有其他调用用于决定

instance

是非

null

的，并将其返回。多线程能够安全并发地执行除第一次调用外的所有调用。尽管如此，由于该方法是

synchronized

的，需要为该方法的每一次调用付出同步的代价，即使只有第一次调用需要同步。

为使此方法更为有效，一个被称为双重检查锁定的习语就应运而生了。这个想法是为了避免对除第一次调用外的所有调用都实行同步的昂贵代价。同步的代价在不同的 JVM 间是不同的。在早期，代价相当高。随着更高级的 JVM 的出现，同步的代价降低了，但出入

synchronized

方法或块仍然有性能损失。不考虑
JVM 技术的进步，程序员们绝不想不必要地浪费处理时间。

因为只有清单 2 中的 //2 行需要同步，我们可以只将其包装到一个同步块中，如清单 3 所示：

清单
3. getInstance() 方法

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

清单 3 中的代码展示了用多线程加以说明的和清单 1 相同的问题。当

instance

为

null

时，两个线程可以并发地进入

if

语句内部。然后，一个线程进入

synchronized

块来初始化

instance

，而另一个线程则被阻断。当第一个线程退出

synchronized

块时，等待着的线程进入并创建另一个

Singleton

对象。注意：当第二个线程进入

synchronized

块时，它并没有检查

instance

是否非

null

。

回页首

双重检查锁定

为处理清单 3 中的问题，我们需要对

instance

进行第二次检查。这就是“双重检查锁定”名称的由来。将双重检查锁定习语应用到清单 3 的结果就是清单 4 。

清单
4. 双重检查锁定示例

public static Singleton getInstance() { if (instance == null) { synchronized(Singleton.class) { //1 if (instance == null) //2 instance = new Singleton(); //3 } } return instance; }

双重检查锁定背后的理论是：在 //2 处的第二次检查使（如清单 3 中那样）创建两个不同的

Singleton

对象成为不可能。假设有下列事件序列：