单例模式

参考文章：http://wuchong.me/blog/2014/08/28/how-to-correctly-write-singleton-pattern/

单例模式应该是所有设计模式里使用最普遍，最容易理解，也是最容易自己发掘的设计模式。
从当前收集的资料来看，目前的单例设计模式主要分为饿汉式，懒汉式，双重检验锁、静态内部类、枚举这5种使用方式，如果还有其他的方式，欢迎大家留言。

废话不多说，先上一段代码。

public class SingletonModel {
    private static SingletonModel instance;

    private SingletonModel() {
    }

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

这是一段标准的懒汉式得单例模式代码，很显然，单例模式要求在整个系统中只能产生一个实例对象，为了保证达到这一目的，需要

1.私有的构造方法

私有的构造方法保证了除本身外无法通过构造方法构造实例。

2.静态实例由类本身产生并向外提供操作方法

由类本身创建一个私有静态实例，外部类不能直接操作该实例，由类提供操作方法对该实例进行操作。

但是，这段代码有很大的缺陷，在多线程的情况下，无法保证每个线程由getInstance方法提供的实例，只进行一次初始化，也就是说是线程不安全的，所以我们要对其进行改造。而且由于其他方面的要求，因此产生了多种写法。

以下讨论的所有代码都是在线程安全的形式下进行

懒汉式

public class SingletonModel {
    private static SingletonModel instance;

    private SingletonModel() {
    }

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

相对于线程不安全的懒汉式，在getInstance方法上加了一个 synchronized 关键字，但是这样做并不高效，因为解决实例初始化的问题，只需要在第一次调用getInstance方法的时候进行就可以了。于是…

双重检验锁

public class SingletonModel {
    private static SingletonModel instance;

    private SingletonModel() {
    }

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

相对于普通的懒汉式，这种方式缩小了同步代码块的范围。

在不同线程进入方法时，可以异步进行第一次instance的非空判断，如果instance 已经初始化，则不在进入同步代码，提高了效率。

如果instance 没有被初始化，则会进入同步代码块，进行初始化。而同步代码块中也需要进行一次instance非空判断，否则两个线程同时进入同步代码块，依然会初始化两次实例。

看上去很完美了是不是？一般来说这样就够了，但是我们深入一点，引用一段其他博主对此的结论，我们来看看。

instance = new SingletonModel ()这句，并非是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情。

1.给 instance 分配内存。
2.调用 Singleton 的构造函数来初始化成员变量。
3.将instance对象指向分配的内存空间（执行完这步 instance 就为非 null 了）。

但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，被线程二抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用，然后顺理成章地报错。

我们只需要将 instance 变量声明成 volatile 就可以了。

public class SingletonModel {
    private volatile static SingletonModel instance;

    private SingletonModel() {
    }

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

有些人认为使用 volatile 的原因是可见性，也就是可以保证线程在本地不会存有 instance 的副本，每次都是去主内存中读取。但其实是不对的。使用 volatile 的主要原因是其另一个特性：禁止指令重排序优化。也就是说，在 volatile 变量的赋值操作后面会有一个内存屏障（生成的汇编代码上），读操作不会被重排序到内存屏障之前。比如上面的例子，取操作必须在执行完 1-2-3 之后或者 1-3-2 之后，不存在执行到 1-3 然后取到值的情况。从「先行发生原则」的角度理解的话，就是对于一个 volatile 变量的写操作都先行发生于后面对这个变量的读操作（这里的“后面”是时间上的先后顺序）。

但是特别注意在 Java 5 以前的版本使用了 volatile 的双检锁还是有问题的。其原因是 Java 5 以前的 JMM （Java 内存模型）是存在缺陷的，即时将变量声明成 volatile 也不能完全避免重排序，主要是 volatile 变量前后的代码仍然存在重排序问题。这个 volatile 屏蔽重排序的问题在 Java 5 中才得以修复，所以在这之后才可以放心使用 volatile。

需要关注的是 volatile 关键字可以禁止指令重排序优化，这是双重检验锁会产生问题的主要方面。

这个太复杂了，我不想研究那么深，那么有没有其他方法了呢？

有！

饿汉式

public class SingletonModel {
    private static final SingletonModel instance=new SingletonModel();

    private SingletonModel() {
    }

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

是不是看上去简单多了。

但是这种方法的缺点也是显而易见的，他不是一个懒加载过程，即使没有使用这个实例，这个实例也会在JVM加载类时被创建。如果你想使用一些参数或者想加载一些properties或者xml中的参数，这种方式就不适用了。

所以我们需要一个新的方法。

静态内部类

public class SingletonModel {
    private SingletonModel() {
    }

    private static class SingletonHolder {
        private static final SingletonModel INSTANCE = new SingletonModel();
    }
    public static final SingletonModel getInstance() {
        return SingletonHolder.INSTANCE;
    }
    
}

这种写法仍然使用JVM本身机制保证了线程安全问题。

由于 SingletonHolder 是私有的，除了 getInstance() 之外没有办法访问它，因此它是懒汉式的。

同时读取实例的时候不会进行同步，没有性能缺陷，也不依赖 JDK 版本。

推荐使用这种方法。

除此之外还有一种不太常见的用法。

枚举

public enum SingletonModel {
    INSTANCE();
}

可以通过SingletonModel.INSTANCE来调用实例，接下来使用的方法就和普通类是一样的。

由于创建枚举默认就是线程安全的，还能防止反序列化导致重新创建新的对象。

但是由于枚举是不能继承的，也会有一定的局限性。

总结

一般来说饿汉式已经可以满足大部分自定义的单例模式，如果明确需要懒加载的情况，可以使用静态内部类或枚举。