深入Java单例模式浅析

　　　在GoF的23种设计模式中，单例模式是比较简单的一种。然而，有时候越是简单的东西越容易出现问题。下面就单例设计模式详细的探讨一下。

　　5. 从源头检查

　　下面我们开始说编译原理。所谓编译，就是把源代码“翻译”成目标代码——大多数是指机器代码——的过程。针对Java，它的目标代码不是本地机器代码，而是虚拟机代码。编译原理里面有一个很重要的内容是编译器优化。所谓编译器优化是指，在不改变原来语义的情况下，通过调整语句顺序，来让程序运行的更快。这个过程成为reorder。

　　要知道，JVM只是一个标准，并不是实现。JVM中并没有规定有关编译器优化的内容，也就是说，JVM实现可以自由的进行编译器优化。

　　下面来想一下，创建一个变量需要哪些步骤呢?一个是申请一块内存，调用构造方法进行初始化操作，另一个是分配一个指针指向这块内存。这两个操作谁在前谁在后呢?JVM规范并没有规定。那么就存在这么一种情况，JVM是先开辟出一块内存，然后把指针指向这块内存，最后调用构造方法进行初始化。

　　下面我们来考虑这么一种情况：线程A开始创建SingletonClass的实例，此时线程B调用了getInstance()方法，首先判断instance是否为null。按照我们上面所说的内存模型，A已经把instance指向了那块内存，只是还没有调用构造方法，因此B检测到instance不为 null，于是直接把instance返回了——问题出现了，尽管instance不为null，但它并没有构造完成，就像一套房子已经给了你钥匙，但你并不能住进去，因为里面还没有收拾。此时，如果B在A将instance构造完成之前就是用了这个实例，程序就会出现错误了!

　　于是，我们想到了下面的代码：


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

　　我们在第一个同步块里面创建一个临时变量，然后使用这个临时变量进行对象的创建，并且在最后把instance指针临时变量的内存空间。写出这种代码基于以下思想，即synchronized会起到一个代码屏蔽的作用，同步块里面的代码和外部的代码没有联系。因此，在外部的同步块里面对临时变量 sc进行操作并不影响instance，所以外部类在instance=sc;之前检测instance的时候，结果instance依然是null。

　　不过，这种想法完全是错误的!同步块的释放保证在此之前——也就是同步块里面——的操作必须完成，但是并不保证同步块之后的操作不能因编译器优化而调换到同步块结束之前进行。因此，编译器完全可以把instance=sc;这句移到内部同步块里面执行。这样，程序又是错误的了!

　　6. 解决方案

　　说了这么多，难道单例没有办法在Java中实现吗?其实不然!

　　在JDK 5之后，Java使用了新的内存模型。volatile关键字有了明确的语义——在JDK1.5之前，volatile是个关键字，但是并没有明确的规定其用途——被volatile修饰的写变量不能和之前的读写代码调整，读变量不能和之后的读写代码调整!因此，只要我们简单的把instance加上 volatile关键字就可以了。


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

　　然而，这只是JDK1.5之后的Java的解决方案，那之前版本呢?其实，还有另外的一种解决方案，并不会受到Java版本的影响：


public class SingletonClass {
　　private static class SingletonClassInstance {
　　private static final SingletonClass instance = new SingletonClass();
　　}
　　public static SingletonClass getInstance() {
　　return SingletonClassInstance.instance;
　　}
　　private SingletonClass() {
　　}
　　}

　　在这一版本的单例模式实现代码中，我们使用了Java的静态内部类。这一技术是被JVM明确说明了的，因此不存在任何二义性。在这段代码中，因为SingletonClass没有static的属性，因此并不会被初始化。直到调用getInstance()的时候，会首先加载 SingletonClassInstance类，这个类有一个static的SingletonClass实例，因此需要调用 SingletonClass的构造方法，然后getInstance()将把这个内部类的instance返回给使用者。由于这个instance是 static的，因此并不会构造多次。

　　由于SingletonClassInstance是私有静态内部类，所以不会被其他类知道，同样，static语义也要求不会有多个实例存在。并且，JSL规范定义，类的构造必须是原子性的，非并发的，因此不需要加同步块。同样，由于这个构造是并发的，所以getInstance()也并不需要加同步。

　　至此，我们完整的了解了单例模式在Java语言中的时候，提出了两种解决方案。个人偏向于第二种，并且Effiective Java也推荐的这种方式。