深入理解单例模式

| 什么是单例模式

单例模式是一种常用的软件设计模式，Java中单例模式的定义为：一个类有且仅有一个实例，并且自行实例化向整个系统提供。

| 为什么要使用单例模式

使用单例模式的目的是使得类的一个对象成为系统中的唯一实例。对于系统中的某些类来说，只有一个实例非常重要，例如，一个系统中可以存在多个打印任务，但是只能有一个正在工作的任务；一个系统只能有一个计时工具（如统计网站来访人数）或ID（序号）生成器；

| 单例模式的优缺点

优点

单例模式可以确保所有对象都访问唯一实例

缺点

1、开销

如果每次对象请求时都要检查是否存在类的实例，会增加一些开销。可以通过使用静态初始化解决这个问题。

2、可能的开发混淆

开发人员必须记住自己不能使用new关键字实例化对象

| 单例模式的几种实现方式

1、饿汉模式

饿汉模式在类加载的时候就创建对象实例，实例在整个程序周期都存在。

public class Singleton {
    private static Singleton instance = new Singleton();
    private Singleton() {
    }
    public static Singleton getInstance() {
        return instance;
    }
}

优点：只在类加载的时候创建一次实例，不会存在多个线程创建多个实例的情况，避免了多线程同步的问题。

缺点：即使这个单例没有用到也会被创建，而且在类加载之后就被创建，内存就被浪费了。

2、懒汉模式

懒汉模式中单例是在需要的时候才去创建的，如果单例已经创建，再次调用获取接口将不会重新创建新的对象，而是直接返回之前创建的对象。

public class Singleton {
    private static Singleton instance = null;
    private Singleton() {
    }
    public static Singleton getInstance() {
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

缺点：懒汉模式并没有考虑线程安全问题，在多线程中可能会并发调用它的getInstance()方法，导致创建多个实例。

懒汉模式加锁解决线程并发问题，实现如下：

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

缺点：每次通过getInstance方法得到singleton实例的时候都有一个试图去获取同步锁的过程，加锁是很耗时的，能避免则避免。

3、双重校验锁

只有当instance为null时，需要获取同步锁，创建一次实例。当实例被创建，则无需试图加锁。

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

优点：实现了延迟加载，解决了线程并发问题，同时解决了执行效率问题。

缺点：由于Java中的指令重排优化，有可能取到状态不正确的对象，从而导致程序出错。

所谓指令重排优化是指在不改变原语义的情况下，通过调整指令的执行顺序让程序运行的更快。由于指令重排优化的存在，导致初始化Singleton和将对象地址赋给instance字段的顺序是不确定的。在某个线程创建单例对象时，在构造方法被调用之前，就为该对象分配了内存空间并将对象的字段设置为默认值。此时就可以将分配的内存地址赋值给instance字段了，然而该对象可能还没有初始化。若紧接着另外一个线程来调用getInstance，取到的就是状态不正确的对象，程序就会出错。这就是双重校验锁会失效的原因，不过还好在JDK1.5及之后版本增加了volatile关键字。

volatile的一个语义是禁止指令重排序优化，也就保证了instance变量被赋值的时候对象已经是初始化过的，从而避免了上面说到的问题。代码如下：

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

4、静态内部类

我们可以把Singleton实例放到一个静态内部类中，这样就避免了静态实例在Singleton类加载的时候就创建对象，并且由于静态内部类只会被加载一次，所以这种写法也是线程安全的：

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

这种方式同样利用了类加载机制来保证只创建一个instance实例。它与饿汉模式一样，也是利用了类加载机制，因此不存在多线程并发的问题。不一样的是，它是在内部类里面去创建对象实例。这样的话，只要应用中不使用内部类，JVM就不会去加载这个单例类，也就不会创建单例对象，从而实现懒汉式的延迟加载。也就是说这种方式可以同时保证延迟加载和线程安全

5、枚举

上面提到的四种实现单例的方式都有共同的缺点：

1）需要额外的工作来实现序列化，否则每次反序列化一个序列化的对象时都会创建一个新的实例

2）可以使用反射强行调用私有构造器（如果要避免这种情况，可以修改构造器，让它在创建第二个实例的时候抛异常）

枚举类很好的解决了这两个问题：

public enum Singleton {  
    INSTANCE;
    public void whateverMethod() {  
    }
}

使用枚举除了线程安全和防止反射强行调用构造器之外，还提供了自动序列化机制，防止反序列化的时候创建新的对象。因此，Effective Java推荐尽可能地使用枚举来实现单例。

| 总结

代码没有一劳永逸的写法，只有在特定条件下最合适的写法。在不同的平台、不同的开发环境（尤其是jdk版本）下，自然有不同的最优解（或者说较优解）。比如枚举，虽然Effective Java中推荐使用，但是在Android平台上却是不被推荐的。比如双重检查锁法，不能在jdk1.5之前使用，而在Android平台上使用就比较放心了（一般Android都是jdk1.6以上了，不仅修正了volatile的语义问题，还加入了不少锁优化，使得多线程同步的开销降低不少）。

最后，不管采取何种方案，请牢记单例的三大要点：线程安全、延迟加载、序列化与反序列化安全。