Java设计模式之单例模式

理论上Java设计模式有23种，在Android中，单例模式是很经常用到的一种设计模式。

什么是单例模式?

当需要控制一个类的实例只能有一个，而且客户只能从一个全局访问点访问它时，可以选用单例模式，这些功能恰好是单例模式要解决的问题。

饿汉式

//最简单的单例模式实现方式。
public class Singleton{

    private static Singleton instance = new Singleton();

    private Singleton(){}

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

**优点：**适合初始化较快占用内存较小的单例对象，在应用启动时直接初始化。因为JVM只会加载一次单例类，线程安全，在多线程的情况下，饿汉式不会出现问题。
**缺点：**不适合「单例对象占用内存较大」，或「初始化耗时长」，或「特定场景才会用到单例」等情况。

懒汉式

public class Singleton{
    private static Singleton instance = null;

    private Singleton(){}

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

**优点：**按需加载，适合「不经常用到单例」、「初始化单例对象耗时较长」等场景。
**缺点：**线程不安全，多线程的情况下容易产生重复创建单例对象的问题。

懒汉式同步锁

public class Singleton{
    private static Singleton instance = null;

    private Singleton(){}

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

**优点：**线程安全。
缺点：

• 效率不高，因为在任何时候只能有一个线程调用 getInstance()
  方法。但是同步操作只需要在第一次调用时才被需要，即第一次创建单例实例对象时。
• 由于JVM即时编译器的指令重排优化，不能保证代码按顺序运行。

主要在于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，然后使用，然后顺理成章地报错。

于是需要加上双重检验锁以及将单例变量声明为volatile

懒汉式（双重检验锁+volatile)

public class Singleton {
    private volatile static Singleton instance; //声明成 volatile
    private Singleton (){}
    public static Singleton getSingleton() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

双重检验锁模式（double checked locking pattern），是一种使用同步块加锁的方法。程序员称其为双重检查锁，因为会有两次检查 instance == null，一次是在同步块外，一次是在同步块内。为什么在同步块内还要再检验一次？因为可能会有多个线程一起进入同步块外的 if，如果在同步块内不进行二次检验的话就会生成多个实例了。
volatile 的主要原因是其一个特性：禁止指令重排序优化，这样就能保证代码按照顺序执行。

静态内部类

public class Singleton{
    //内部类，在装载该内部类时才会去创建单利对象
    private static class SingletonHolder{
        public static Singleton instance = new Singleton();
    }
    private Singleton(){}
    public static Singleton newInstance(){
        return SingletonHolder.instance;
    }
    public void doSomething(){
        //do something
    }
}

**优点：**这种写法仍然使用JVM本身机制保证了线程安全问题；由于 SingletonHolder 是私有的，除了 getInstance() 之外没有办法访问它，因此它是懒汉式的；同时读取实例的时候不会进行同步，没有性能缺陷；也不依赖 JDK 版本。

枚举类型单例模式

public enum Singleton{
    //定义一个枚举的元素，它就是Singleton的一个实例
    instance;
    public void doSomething(){
        // do something ...
    }
}

**优点：**我们可以通过EasySingleton.INSTANCE来访问实例，这比调用getInstance()方法简单多了。创建枚举默认就是线程安全的，所以不需要担心double checked locking，而且还能防止反序列化导致重新创建新的对象。
**缺点：**在Android中使用枚举，内存占用上是静态变量的两倍以上。

总结

一般来说，单例模式有五种写法：懒汉、饿汉、双重检验锁、静态内部类、枚举。
相对来说比较完美的时静态内部类和枚举类。