本文从单例模式的一般实现方式开始说起，逐步深入到双重加锁实现。

1. 首先介绍一下最简单的单例模式——饿汉模式，这种方式在单例类被加载的时候实例化。代码实现如下：

1 public class Singleton {
 2     private static Singleton instance;
 3     
 4     static {
 5         instance = new Singleton();
 6     }
 7 
 8     private Singleton() {
 9     }
10 
11     public static Singleton getInstance() {
12         return instance;
13     }
14 }

饿汉模式的缺点在于，如果单例对象的创建过程比较耗时，那么应用程序的启动将会比较慢。

2. 为了克服饿汉模式的缺点，将单例对象的创建过程延后到第一次使用单例对象时，这种实现方式被称为懒汉模式。代码实现如下：

1 public class Singleton {
 2     private static Singleton instance;
 3     
 4     private Singleton() {
 5     }
 6     
 7     public static Singleton getInstance() {
 8         if (instance == null) {
 9             instance = new Singleton();
10         }
11         
12         return instance;
13     }
14 }

线程不安全的。假设在单例类被实例化之前，有两个线程同时在获取单例对象，线程1在执行完第8行 if (instance == null) 后，线程调度机制将 CPU 资源分配给线程2，此时线程2在执行第8行  if (instance == null) 时也发现单例类还没有被实例化，这样就会导致单例类被实例化两次。为了防止这种情况发生，需要对 getInstance() 方法同步。下面看改进后的懒汉模式：

1 public class Singleton {
 2     private static Singleton instance;
 3     
 4     private Singleton() {
 5     }
 6     
 7     // 线程安全的懒汉模式
 8     public synchronized static Singleton getInstance() {
 9         if (instance == null) {
10             instance = new Singleton();
11         }
12         
13         return instance;
14     }
15 }

3. 双重加锁（double check）

      第2种实现方式中，每次获取单例对象时都会加锁，这样就会带来性能损失。双重加锁实现本质也是一种懒汉模式，相比第2种实现方式将会有较大的性能提升。代码实现如下：

1 public class Singleton {
 2     private volatile static Singleton instance;
 3     
 4     private Singleton() {
 5     }
 6     
 7     public static Singleton getInstance() {
 8         if (instance == null) {
 9             synchronized (Singleton.class) {
10                 if (instance == null) {
11                     instance = new Singleton();
12                 }
13             }
14         }
15         
16         return instance;
17     }
18 }

volatile

      补充：第9行可以锁住任何一个对象，要进入临界区必须获得这个对象的锁。由于并不知道其它对象的锁的用途，所以这里最好的方式是对 Singleton.class 进行加锁。