单例模式一点心得

单例模式算是设计模式中最容易理解的，最容易手写代码的设计模式。面试时也会常常会被问到用过什么设计模式时，最能脱口而出的就是单例模式了。

具体的定义优点什么的就不详述了，这里主要记录下我平常写单例及优化的一点心得。

懒汉式

很多人包括我写单例的时候，第一想到的就是懒汉式

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

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

代码很简单，而且是懒加载，只有调用getInstance方法是才会初始化。但是这样是线程不安全的，即当多个线程并行调用getInstance的时候，就会创建多个实例，不能正常工作。

所以这里就有了加锁方式，将整个getInstance方法设为同步，添加synchronized关键字。

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

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

这样简单粗暴的方式，虽然做到了线程安全，但导致了同一时间内只能有一个线程能够调用getInstance方法。

其实我们仅仅需要对初始化的代码进行同步，这就有了双重检验锁方式。

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

    public static Singleton getInstance() {
        if (instance == null) {              //第一次检查
            synchronized (Singleton.class) {
                if(instance == null) {      //第二次检查
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

这里第二次检查，是因为如果有多个线程同时执行完了第一次检查，这时如果同步块内不进行第二次检查的话，会生成多个实例了。

但是看了相关资料后，发现这样还是有点问题。引用资料中的介绍：

由于instance = new Singleton()，这并非是一个原子操作，事实上在 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 Singleton {
    private volatile static Singleton instance;
    private Singleton (){}

    public static Singleton getInstance() {
        if (instance == null) {              //第一次检查
            synchronized (Singleton.class) {
                if(instance == null) {      //第二次检查
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

现在，这才是目前懒汉式单例最优的写法。

饿汉式

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

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

这种方法最简单，而且是线程安全，但缺点是不是懒加载，类一旦加载到内存中就会初始化。在类的构造函数如果要传入参数的情况下，饿汉式是不适用的。

枚举单例

public enum Singleton {
    INSTANCE;
    private Singleton (){}

    public void method() {
        //TODO ...
    }
}

这种写法最简单，利用枚举量来保证单例，同样是线程安全的，而且枚举解决了序列化和反射攻击。

总结

单例模式是运用频率很高的设计模式，其实在app中通常没有高并发的情况，所以选择哪种写法并不会产生多大的影响。但出于效率考虑，我推荐用懒汉式的使用双重校验锁方式，或者用枚举单例。