一、单例模式的意义

Design Patterns 一书中对单例模式的整体性描述是这样一句话：

Ensure a class only has one instance, and provide a global point of access to it.
确保一个Class只有一个实例，并对外提供一个全局访问点。

单例模式是最容易理解的设计模式。道理简单，不过如何写出一个“正确”的单例模式一开始并不简单。Talk is cheap. Show me the code.

单例模式的代码有两种不同的方式，一种被叫做所谓的“饿汉式”，另一种叫“懒汉式”。

二、饿汉方式

饿汉的意思是：急切的……，即急切的创建实例。代码如下：

/**
 * “饿汉式”，即“急切的方式”。
 */
public class Singleton {

    private static Singleton instance = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return instance;
    }
}

优点：实现简单、线程安全，JVM保证在任何线程能访问instance之前，实例化new Singleton()已被执行完成。
缺点：如果实例化new Singleton()很耗资源，而对象在很久之后才会被用到或者本次程序运行中都用不到，则浪费了系统资源。

三、懒汉方式（懒加载）

针对“急切方式”的缺点，可以使用这种称为“懒加载”的方式来实现单例模式。

1. 第一遍代码：错误代码1

/**
 * 懒汉式，错误代码1
 * <p>
 * 错误原因：线程不安全。安全写法见${@link LazyInitializationCorrect}
 * </p>
 */
public class LazyInitializationError {

    private static LazyInitializationError instance;

    private LazyInitializationError() {}

    public static LazyInitializationError getInstance() {
        if (instance == null) {
            instance = new LazyInitializationError();
        }
        return instance;
    }
}

错误发生流程：

线程Thread1执行完if (instance == null)后失去了CPU执行权。
线程Thread2再次执行了if (instance == null)并得到true，然后它也失去执行权。
Thread1恢复执行，实例化了一个对象并赋值给了instance，return给调用方。
Thread2恢复执行，它不知道instance已经不为null，所以会再次实例化一个新对象并return给调用方。

2. 第二遍代码：有性能损耗

/**
 * 懒汉式，性能有损耗
 */
public class LazyInitializationSlowly {
    private static LazyInitializationSlowly instance;

    private LazyInitializationSlowly (){}

    public static synchronized LazyInitializationSlowly getInstance() {
        if (instance == null) {
            instance = new LazyInitializationSlowly();
        }
        return instance;
    }
}

缺点：每次调用getInstance()都需要先获取锁，造成资源损耗。

3. 第三遍代码：错误代码2

使用Double-checked locking 可以避免效率降低，请看以下代码。不过注意：下面代码其实仍有问题，具体在注释中。

/**
 * 懒汉式，错误代码2
 *
 * <p>
 * 使用了“Double-checked locking”，但不幸的是，在Java环境下注意这是又一个错误的写法，错误描述见代码注释
 * <br>安全写法见${@link LazyInitializationCorrect}
 * </p>
 */
public class LazyInitializationErrorNoVolatile {

    private static LazyInitializationErrorNoVolatile instance;

    private LazyInitializationErrorNoVolatile() {}

    /**
    * Double-checked locking
    */
    public static LazyInitializationErrorNoVolatile getInstance() {
        // first check 第一次检查并不会尝试获取锁，避免了性能损耗
        if (instance == null) {
            synchronized (LazyInitializationErrorNoVolatile.class) {
                // double check
                if (instance == null) {
                    instance = new LazyInitializationErrorNoVolatile();
                    // 一、上面这句代码在JVM中被分解为3个指令
                    // 1. 为对象分配内存空间（例如内存地址为：10001）。
                    // 2. 调用构造函数初始化对象。
                    // 3. 局部变量instance 指向对象被分配的内存空间。（即10001，执行完这步后instance 非null ）

                    // 二、问题：
                    // 由于JVM的JIT编译器存在着称为“指令重排序”的优化行为，所以上面这行代码的指令执行顺序并非一定是“1-2-3”，
                    // 有可能被优化为“1-3-2”，这在Java内存模型中是完全合法的。所以错误出现在：
                    // 1. Thread1执行指令的顺序为“1-3-2”且在执行了“1-3”后丢失了CPU的执行权，此时3已执行所以instance为非null；
                    // 2. Thread2获取执行权，当执行到first check 时，发现结果为false所以直接return instance，然而此时instance指向的对象并没有初始化完成，随即程序可能崩溃。

                    // 三、解决问题：
                    // JDK1.5后volatile的语义被扩展了，使用volatile关键字即可解决。
                    // volatile的一个语义是：阻止指令重排序优化，使得上面执行的顺序必须是“1-2-3”即可。
                }
            }
        }
        return instance;
    }
}

4. 第四遍代码：正确写法

即上例代码的有volatile版本。

/**
 * 懒汉式，正确写法
 */
public class LazyInitializationCorrect {

    private static volatile LazyInitializationCorrect instance;

    private LazyInitializationCorrect() {}

    public static LazyInitializationCorrect getInstance() {
        // Double-checked locking
        if (instance == null) {
            synchronized (LazyInitializationCorrect.class) {
                if (instance == null) {
                    instance = new LazyInitializationCorrect();
                }
            }
        }
        return instance;
    }
}

四、另一种正确的懒加载

懒加载还有一种效率更高的正确写法叫 Initialization-on-demand holder idiom，这种方式效率很高因为没有同步代码，当然它也有一定的局限性，这些在注释中详细的写了出来：

/**
 * 懒汉式，使用Hodler方式
 *
 * <p>完全线程安全，“Initialization-on-demand holder idiom”，但有一定限制</p>
 */
public class LazyInitializationCorrectWithHolder {

    private LazyInitializationCorrectWithHolder() {}

    // 1. LazyInitializationCorrectWithHolder被JVM加载时，如果Holder类没被任何代码引用到的话，是不会被加载的，所以这里满足了“懒”；
    private static class Holder {
        private static final LazyInitializationCorrectWithHolder INSTANCE = new LazyInitializationCorrectWithHolder();
    }

    public static LazyInitializationCorrectWithHolder getInstance() {
        // 2. 当外部代码调用 getInstance() 时，Holder才会被加载并执行；
        // 3. 又由于JVM保证了class的初始化是按照既定顺序的，不会多线程的，所以 INSTANCE 的初始化是线程安全的。
        return Holder.INSTANCE;
    }

    // 4. 使用这种风格的单例，必须满足一个条件，构造函数的过程不能发生异常导致初始化失败。（double checked方式没有这个限制）
    // 错误代码如下，当初始化失败后，其它线程也不能再次完成初始化了，因为会一直发生LazyInitializationCorrectWithHolder$Holder NoClassDefFoundError
    // private LazyInitializationCorrectWithHolder() {
    //     if (Thread.currentThread().getName().equals("Threadddd-0")) {
    //         int i = 1/0;
    //     }
    // }
    // public static void main(String[] args) {
    //     for (int i = 0; i < 3; i++) {
    //         final Thread thread = new Thread(new Runnable() {
    //             @Override
    //             public void run() {
    //                 getInstance();
    //             }
    //         });
    //         thread.setName("Threadddd-" + i);
    //         thread.start();
    //     }
    // }
}

单例模式很简单，不过如果你一开始无法预料到一些潜在的问题，其实也很难写出正确的代码。看过了这篇文章，相信你再也写不错了。

转载注明出处：http://blog.csdn.net/u010297957/article/details/70544003

单例模式 - Singleton Patterns