Android 深入理解单例模式

一、前言

本文主要记录使用单例模式的几种形式，并分析各自的优缺点。使用单例模式可以避免重复创建对象，以此来节省开销，首先了解一下单例模式的四大原则：

• 构造方法私有

• 以静态方法返回实例

• 实例唯一，尤其在多线程环境

• 反序列化时不会重新构造对象

---

二、常用单例模式介绍

常用的单例模式有：饿汉模式、懒汉模式、双重锁懒汉模式、静态内部类模式、枚举模式，我们来逐个解释这些模式的区别。

A、饿汉模式

/**
 * 懒汉模式：在类初始化时创建对象，所以不存在线程安全问题，以空间换时间
 */
public class SingleTonHungry {
    private static SingleTonHungry INSTANCE = new SingleTonHungry();

    private SingleTonHungry() {
    }

    public static SingleTonHungry getInstance() {
        return INSTANCE;
    }
}

B、懒汉模式

/**
 * 懒汉模式：在 getInstance() 方法被调用后才创建对象，以时间换空间
 * 在多个线程同时调用 getInstance() 时，就会创建多个对象，故在多线程环境下有风险
 */
public class SingleTonLazy {
    private static SingleTonLazy INSTANCE = null;

    private SingleTonLazy() {
    }

    public static SingleTonLazy getInstance() {
        if (INSTANCE == null) {
            return new SingleTonLazy();
        }
        return INSTANCE;
    }
}

C、双重锁懒汉模式（Double Check Lock）

/**
 * DCL模式(Double Check Lock)，这是懒汉模式的升级版
 * 解决了多线程同时调用 getInstance() 产生多个对象的问题
 */
public class SingleTonDCL {
    private static volatile SingleTonDCL INSTANCE = null;

    private SingleTonDCL() {
    }

    public static SingleTonDCL getInstance() {
        // 此处判空，是为了提高性能，对象不为空的情况下就不阻塞线程
        if (INSTANCE == null) {
            // 加锁，同步线程
            synchronized (SingleTonDCL.class) {
                // 若多个线程在未初始化对象时同时调用 getInstance() 方法，那么未抢占到锁的线程在得
                // 到锁之后，直接去创建对象，还是会创建多个对象，所以这里也需要判断空
                if (INSTANCE == null) {
                    return new SingleTonDCL();
                }
            }
        }
        return INSTANCE;
    }
}

关于 volatile 修饰符，又是一个内容，需要理解：

参考（有例子，比较好理解）：https://www.cnblogs.com/blog-Aevin/p/9302678.html，https://www.jianshu.com/p/ccfe24b63d87

D、静态内部类模式

/**
 * 静态内部类单例模式
 */
public class SingleTonStatic {

    public SingleTonStatic() {
    }

    public static SingleTonStatic getInstance() {
        return SingleTonStaticHolder.INSTANCE;
    }

    private static class SingleTonStaticHolder {
        private static final SingleTonStatic INSTANCE = new SingleTonStatic();
    }
}

静态内部类单例模式的优点：

• 延迟实例化

  当一个外部类在被加载时，不会马上去加载它的静态内部类。所以这里的静态内部类 SingleTonStaticHolder 不会马上被加载，直到 getInstance() 方法被调用，才会去加载并创建 SingleTonStatic 实例。

• 保证线程安全性、实例唯一性

  当 getInstance() 方法被调用时，SingleTonStaticHolder 才在 SingleTonStatic 的运行时常量池里，把符号引用替换为直接引用。这时静态对象 INSTANCE 也真正被创建，然后再被 getInstance() 方法返回出去。这和饿汉模式类似，在类初始化时就创建对象，所以不存在线程安全问题。

那么有人会问了，如果有多个线程同时访问 getInstance() 方法，会多次初始化类，然后创建多个对象吗？答案是不会的，这我们需要了解一下类的加载机制：

虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的<clinit>()方法，其他线程都需要阻塞等待，直到活动线程执行<clinit>()方法完毕。

所以如果一个类的<clinit>()方法中有耗时很长的操作，就可能造成多个进程阻塞(需要注意的是，其他线程虽然会被阻塞，但线程唤醒之后不会再次进入<clinit>()方法。因为在同一个加载器下，一个类只会初始化一次。)

所以静态内部类单例模式不仅能保证线程的安全性、实例的唯一性、还延迟了单例的实例化。

但是静态内部类单例模式也有一个缺点，就是无法传递参数。因为它是通过静态内部类的形式去创建单例的，所以外部就无法传递参数进去。

---

E、枚举模式

/**
 * 枚举单例模式
 */
public enum  SingleTonEnum {
    INSTANCE;
}

枚举单例模式占用的内存是静态变量的两倍，所以一般都不使用enum来实现单例。

---

三、总结

单例有饿汉模式、懒汉模式、双重锁懒汉模式、静态内部类模式、枚举模式这几种形式。

饿汉模式在初始化类时就创建了对象，容易造成资源浪费；懒汉模式在多线程环境下有风险；枚举模式占用内存过高。这三种模式都有明显的弊端，所以一般不去采用。

双重锁懒汉模式使用了 volatile 修饰符，在性能上会差一点点；静态内部类模式无法传递参数。但是这两种方式都能保证实例的唯一性，线程的安全性，也不会造成资源的浪费。所以我们在使用单例模式时，可以在这两种方式中酌情选择。

参考文章：https://blog.csdn.net/mnb65482/article/details/80458571