单例模式之进化心路

前言

单例模式应该是编程中使用最多的设计模式之一，写好单例模式往往能体现一个程序员的基本功。单例模式看似简单，但是要将其设计得高效、安全、优雅，还是需要考虑很多细节之处。本文将从最简单的单例模式开始分析，从简单-高效-安全-优雅逐步演化。

非线程安全版

简单版只需实现单例功能，并不考虑其他因素。同时简单版分饿汉和懒汉模式，至于何为饿汉何为懒汉，接下来将逐一介绍。

1. 饿汉模式

何为饿汉模式，简单形象来说就是像饿汉一样，很饥饿，需要立马得到食物。在代码中体现就是，一开始就得把单例对象创建出来，需要时立马就能拿到，不需要其他额外操作。代码如下所示：

public class Singleton {
    private Singleton() {}
    // 饿汉模式
    private static Singleton instance = new Singleton();
    public static Singleton getInstance() {
        return instance;
    }
}

从上面的代码可以看出，饿汉模式相当简单，同时，这种方式也存在一些问题，一是静态成员变量instance 在一开始就会被创建出来，即使整个运行阶段都未使用，也会占用内存；另一个是线程不安全，在多线程环境下会创建多个对象。针对这两个问题，下面会逐一解决。

2. 懒汉模式

和饿汉模式相反，懒汉模式如同其名，在对象需要使用时才创建出来，避免饿汉模式导致的内存浪费。代码如下所示：

public class Singleton {
    private Singleton() {}
    // 懒汉模式
    private static Singleton instance = null;
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

可以看到，懒汉模式也很简单，instance 初始化为null，只有在需要使用时才去创建对象，解决了饿汉模式内存浪费问题，但是线程安全问题依旧没解决。下一小节将讨论线程安全单例模式如何实现。

线程安全版

在编写多线程程序时，线程安全是最基本也是最重要的考虑之一。接下来，我们将讨论线程安全版本单例模式的几种实现方式。

1. 简单粗暴法

大家很容易想到，要想保证线程安全那直接在方法前加锁使其成为同步方法，那么在多线程同时调用方法时，需要排队执行同步块，保证了线程的安全。这种实现方式如下：

public class Singleton {
    private Singleton() {}
    private static Singleton instance = null;

    // 同步方法
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

上诉方法在getInstance前加synchronized 关键字保证方法的同步调用，实现了线程安全版的单例模式，这种方法简单而且也达到了目的，但是缺陷是效率极低，每次调用方法获取单例对象时都得加锁，如果调用频繁则对程序性能影响很严重。针对效率问题，下面会给出解决方法。

2. Double CheckLock（DCL）法

既然每次加锁会导致效率问题，那我们可以考虑是否可以缩小锁的粒度，在必须加锁的情况下才加锁，其他情况直接饶过加锁操作。如下所示：

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

大家注意到，只有当单例对象为空时，才进入同步代码块，不为空时，直接返回对象，这种方式对比上一种实现方式极大提高了程序的性能。同时，这里有两次判空操作，有些同学可能疑惑为什么需要两次，这里解释下：第一次判空，相信大家都能理解，即当对象为空时才进入同步块；第二次判空是为了避免这种情况---当多个线程同时通过了第一次判空，进入同步块，如果没有第二次判断操作，则会创建出多个单例对象。这种方法解决了性能问题，但是依旧有不足之处，那内存浪费和线程安全都解决了，那存在什么不足呢？这种方式真的就线程安全了吗？no，这里还涉及到比较底层的细节---jvm编译器指令重排。何为指令重排，相信大家都了解，如上面一行代码instance = new Singleton();编译成jvm指令可能如下：

address = allocate(); // 1. 给对象分配内存空间
ctorInstance(address); // 2. 初始化对象
instance = address; // 3. 将instance指向对象

如果编译器不搞事，正常情况下，按上面的jvm指令执行不会出现线程安全问题，但是如果jvm按照自己的优化算法将上诉指令进行优化，就会出现下面这种情况：

address = allocate(); // 1. 给对象分配内存空间
instance = address; // 2. 将instance指向对象
ctorInstance(address); // 3. 初始化对象

那如果按照上面的指令顺序运行会出现什么问题呢，为了能够形象的解释这一问题，我把上诉执行替换到java代码中，如下：

public class Singleton {
    private Singleton() {}
    private static Singleton instance = null;
    public static Singleton getInstance() {
        if (instance == null) {  // first check
            synchronized (Singleton.class) {
                if (instance == null) { // second check
                   address = allocate(); // 1. 给对象分配内存空间
                   instance = address; // 2. 将instance指向对象 （注意，执行完这条命令后，instance将不为null）
                   ctorInstance(address); // 3. 初始化对象
                }
            }
        }
        return instance;
    }
}

按照上诉代码的执行逻辑，假设有两个线程a、b。当a线程通过了两次check，执行完instance = address后，此时instance的状态是不为null且未被初始化，假设此时b线程运行到第一次判空检查发现instance已不为null，那直接返回instance，那么问题就来了，虽然此时instance不为null，但是其并未被初始化，如果直接拿来使用必然会导致程序出错。因此出现线程安全问题。那么如何解决指令重排的问题呢？这里引入volatile关键字防止jvm指令重排，如下所示：

public class Singleton {
    private Singleton() {}
    private volatile static Singleton instance = null;  // 防止指令重排
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

3. 静态内部类实现模式

前面的方法已经解决了内存浪费、效率及线程安全问题，那还有没有更加优雅的方法呢？答案是肯定的，这里引入静态内部类实现方法，即能解决上诉所有问题也能体现出代码的优雅感，如下：

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

内部类是延时加载的，也就是说只会在第一次使用时加载，不使用就不加载。使用内部类可以在不加锁的情况下，保证线程安全，因此用内部类能够优雅的实现单例模式。

小结

本文从内存、性能、安全角度出发，对单例模式的实现逐步演进，在保证这三者的前提下最终讨论出一种优雅的实现方法。如有不足之处，欢迎交流讨论，谢谢。