在Java多线程程序中，有时候需要采用延迟初始化来降低初始化类和创建对象的开销。双重检查锁定是常见的延迟初始化技术，但它是一个错误的用法。下面我们以单例模式为例子来分析双重检查锁定的错误根源。
下面以懒汉式单例模式为例子：

  public class UnsafeLazyInitialization {
    
    private static Instance instance;
    
    public static Instance getInstance() {
        if(instance == null)             // 1: A线程执行 
            instance = new Instance();   // 2: B线程执行
        return instance;
    }
}

在UnsafeLazyInitialization类中，假设A线程执行代码1的同时，B线程执行代码2。此时，线程A可能会看到instance引用的对象还没初始化完成，所以A线程可能会返回一个尚未初始化完成的对象。

创建对象的实际步骤可以分解为如下三行伪代码

• memory = allocate(); //1：分配对象的内存空间
• ctorInstance(memory); //2：初始化对象
• instance = memory; //3：设置instance指向刚分配的内存地址
  但是由于上述伪代码可能会被重排序（编译器和处理器都可能会对代码指令进行重排序）重排序后可能会发生如下情况：
• memory = allocate(); //1：分配对象的内存空间
• instance = memory; //2：设置instance指向刚分配的内存地址
//注意：此时对象还没有被初始化！
• ctorInstance(memory); //3：初始化对象

对于上述问题，我们可以对getInstance方法做同步处理来实现安全的延迟初始化，如下：

public class UnsafeLazyInitialization {

    private static Instance instance;

    public synchronized static Instance getInstance() {
        if(instance == null)            // 1: A线程执行
            instance = new Instance();  // 2: B线程执行
        return instance;
    }
}

由于对getInstance方法做了同步处理，synchronized将导致性能开销增加，如果getInstance方法被多个线程频繁调用，将会导致程序执行性能的下降。反之，这个延迟初始化方案将能提供不错的性能。
在早期的JVM中（synchronized未被优化之前），synchronized存在巨大的性能开销，因此人们想出了一个“聪明”的技巧--双重检查锁定，通过双重检查锁定来降低同步的开销。下面是双重检查锁定实现延迟初始化的例子：

public class DoubleCheckedLocking {

    private static Instance instance;

    public static Instance getInstance() {
        if(instance == null) {                               // 第一次检查
            synchronized (UnsafeLazyInitialization.class) {  // 加锁
                if(instance == null)                         // 第二次检查
                    instance = new Instance();               // 出问题的根源
            }
        }
        return instance;
    }
}

如上述代码所示，如果第一次检查instance不为null，则不需要加锁和初始化操作，因此可以大幅降低synchronized带来的性能开销，表面上看起来似乎两全其美

• 多个线程试图在同一时间创建对象时，会通过加锁来保证只有一个线程可以创建对象。
• 对象创建好之后，执行getInstance方法将不需要再获取锁，直接返回已创建好的对象。

但是与上述代码问题相同（指令重排序问题），当线程执行到第6行时，代码读取到instance的值不为null，则依旧可能返回一个没有初始化完成的对象。

解决方案：

基于volatile

由于在之前的文章中有提到由volatile修饰的变量的读写具有原子性，同时也不会被指令重排序，基于这一特点我们可以将代码修改为如下方案：

public class SafeDoubleCheckedLocking {

    private volatile static Instance instance;

    public static Instance getInstance() {
        if(instance == null) {
            synchronized (SafeDoubleCheckedLocking.class) {
                if(instance == null)
                    instance = new Instance();  // instance为volatile,现在没有问题了
            }
        }
        return instance;
    }
    
}

注意这个解决方案需要JDK 5及以上版本，因为从JDK 5开始使用JSR-133内存模型规范，这个规范增强了volatile的语义

基于类初始化

由于JVM在类的初始化阶段（即在Class被加载后，且被线程使用之前），会执行类的初始化。在执行类的初始化期间，JVM会去获取一个锁，这个锁可以同步多个线程对同一个类的初始化。

基于这个特性，可以实现另一种线程安全的延迟初始化方案。代码如下：

public class InstanceFactory {

    private static class InstanceHolder {
        public static Instance instance = new Instance();
    }

    public static Instance getInstance() {
        return InstanceHolder.instance;   // 这里将导致InstanceHolder类被初始化
    }

}

这个方案的实质是：即使有多个线程同时访问getInstance方法，由于类初始化规范（下述第4条），同步访问的线程也需要等待类初始化完成（包括类中的静态字段，静态代码块，静态方法等）之后才能继续执行其他操作。

Java语言规范规定，对于每个类或者接口C，都会有一个唯一的初始化锁LC与之对应。
当代码中首次发生下列任意一种情况时，一个类或接口类型T将被立即初始化。

• T是一个类，而且一个T类型的实例被创建。
• T是一个类，且T中声明的一个静态方法被调用。
• T中声明的一个静态字段被赋值。
• T中声明的一个静态字段被使用，而且这个字段不是一个常量字段。
• T是一个父类，并且其子类有上述操作。

单例模式的其他实现：

饿汉式：

它基于 classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。

public class HungerSingleton {

    private static HungerSingleton instance = new HungerSingleton();

    // 私有化构造函数不允许其他类创建对象
    private HungerSingleton() {
    }

    public static HungerSingleton getInstance() {
        return instance;
    }

}

枚举：

这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。
这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化，并且不能通过反射来调用私有构造方法。不过，由于 JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。

public enum EnumSingleton {

    INSTANCE;

    // 实例方法
    public void whateverMethod() {
    }

}

总结

总结几种单例模式的实现的优缺点：