Android 架构师1 设计模式之单例模式

前言：

Java中单例模式是一种广泛使用的设计模式。单例模式的主要作用是保证在Java程序中，某个类只有一个实例存在。一些管理器和控制器常被设计成单例模式。
单例模式有很多好处，不仅可以减少每次创建对象的时间开销，还可以节约内存空间；能够避免由于操作多个实例导致的逻辑错误。

单例模式有很多写法，下面就主要的几种写法列举如下：

1. 饿汉式：

饿汉式，顾名思义就是一开始创建该类的时候，就创建了该实例。

public class SingletonHungry {
    //私有化构造方法
    private SingletonHungry() {

    }

    //直接创建对象
    private static SingletonHungry instance = new SingletonHungry();

    //对外提供公共的访问方法
    public static SingletonHungry getInstance() {
        return instance;
    }
}

因为加载类的时候就会创建实例，所以线程安全的（多个ClassLoader存在时例外），但是不是延迟加载，开发中很多时候都是尽量采取需要的时候，才去创建该实例。

2. 懒汉式：

懒汉式，一开始并不会创建该类的实例，而是等到真正要用的时候，才会去创建实例，即延迟加载。

public class SingletonLazy {
    //私有化构造方法
    private SingletonLazy() {

    }

    //创建本类对象的引用
    private static SingletonLazy instance;

    //对外提供公共的访问方法
    public static synchronized SingletonLazy getInstance() {
        if (instance == null) {
            instance = new SingletonLazy();
        }
        return instance;
    }
}

上述写法是线程安全的，当线程A和线程B都去调用getInstance方法的时候，synchronized关键字就会让先到的线程A获取锁，而线程B则会等待，直到线程A释放锁；同时并不像饿汉式那样一开始就创建本类对象的实例，而是需要的时候才会创建实例，达到了延迟加载的效果；但是又由于synchronized关键字影响效率，这样写效率比较低，因为每次调用都会进行synchronized同步。

3. 双重校验锁（Double Check Lock）：

public class SingletonDCL {
    //私有化构造方法
    private SingletonDCL() {

    }

    //创建本类对象的引用
    private static SingletonDCL instance;

    //对外提供公共的访问方式
    public static SingletonDCL getInstance() {
        if (instance == null) {
            synchronized (SingletonDCL.class) {
                if (instance == null) {
                    instance = new SingletonDCL();
                }
            }
        }
        return instance;
    }
}

我们知道，第一个判断是否为空，是为了解决懒汉式的效率问题，当创建好了之后，就只需要进行判断是否为空，而不需要进行同步操作，提高了效率；那么第二个是否为空，是为了解决什么呢？其实是这样的：当线程A获得了锁，并创建了该类的实例对象的时候，即intance = new SingletonDCL()已经走了，那么这时候线程A释放锁，线程B获得了锁，如果不加判断，线程B势必也会再新创建一个对象，这不符合单例的本意，所以这里还需要再加一层判断，这也就是双重校验的来历。
但是上述的做法在高并发的情况下，仍然会有问题，只不过这种概率很小，所以很少人注意到。
其实Java内存模型规定了所有的变量都存储在主内存中。每条线程中还有自己的工作内存，线程的工作内存中保存了被该线程所使用到的变量（这些变量是从主内存中拷贝而来）。线程对变量的所有操作（读取，赋值）都必须在工作内存中进行。不同线程之间也无法直接访问对方工作内存中的变量，线程间变量值的传递均需要通过主内存来完成。这就存在一个问题，一个线程A如果修改了某个变量，而没有及时写回到主内存，这时候另一个线程B使用这个变量，这个变量并不是线程A修改后的值。而例子中，也可能导致线程A虽然初始化了该实例，但是并没有写入主内存，这时候线程B使用该实例，得到的仍然是null。那这个问题，该怎么解决呢？这时候我们需要注意到Java中的volatile关键字。
一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：
1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
2）禁止进行指令重排序。

使用volatile修饰之后就变得不一样了：
第一：使用volatile关键字会强制将修改的值立即写入主存。
第二：使用volatile关键字的话，当线程B进行修改时，会导致线程A的工作内存中缓存变量的缓存行无效。
第三：由于线程A的工作内存中缓存变量的缓存行无效，所以线程1再次读取变量的值时会去主存读取。

接下来，我们只需将instance变量加上volatile关键字修饰即可：

public class SingletonDCL {
    //私有化构造方法
    private SingletonDCL() {

    }

    //创建本类对象的引用
    private static volatile SingletonDCL instance;

    //对外提供公共的访问方式
    public static SingletonDCL getInstance() {
        if (instance == null) {
            synchronized (SingletonDCL.class) {
                if (instance == null) {
                    instance = new SingletonDCL();
                }
            }
        }
        return instance;
    }
}

看完了这些，我们是不是还没有细细深究一下，为什么构造方法、成员变量是用private修饰的，而成员变量又是用static修饰的？至于为什么提供的访问方法使用public修饰的，大家应该都知道，因为我们需要对外提供公共的访问方式。那么接下来我们就这两个问题来探讨一下，等等，先别看下面的讨论，你可以自己先想一想：
首先构造方法、成员变量用private修饰，其实是为了对外隐藏创建的方式，不允许其它类自由创建这个类的对象，同时兼有封装的效果，只对外暴露公共的访问方式。
接下来我们讨论第二个问题，成员变量用static修饰，其实由于单例模式是只创建一个对象，而我们怎么知道只创建了一个对象呢？这时候就需要我们去缓存这个已经创建好的变量，而达到缓存的目的，同时又由于getInstance方法是静态的方法，故我们就需要将这个变量用static修饰。
讨论完这些，是不是整个人都神清气爽了呢？哈哈，真理总是掌握在少数人的手里！

4. 静态内部类：

public class SingletonInnerClass {
    private SingletonInnerClass() {

    }

    private static class SingletonHolder {
        private static SingletonInnerClass instance = new SingletonInnerClass();
    }

    public static SingletonInnerClass getInstance () {
        return SingletonHolder.instance;
    }
}

静态内部类写法避免了静态实例在SingletonInnerClass类加载的时候就创建了对象，达到了延时加载的目的，并且由于静态内部类只会被加载一次，所以又是线程安全的。

5. 单例模式在Android中的应用：

LayoutInflater、WindowManager、ActivityManager、PowerManager。

6. 总结

关于单例模式的枚举写法就不在此列举了，由于内存等方面原因，Android是不推荐枚举的。单例模式的写法多种多样，每一种写法都有自己本身的优点与缺点，主要结合自己的需求去合理地使用。

喜欢本篇博客的简友们，就请来一波点赞，您的每一次关注，将成为我前进的动力，谢谢！