Android设计模式-单例模式-创建型-(3)

创建型模式 (3)

简单工厂、工厂法、抽象工厂模式、单例模式、建造者模式

行为型模式 (2)

观察者模式、策略模式

结构型模式 (3)

适配器模式、代理模式、装饰模式

• Android设计模式Github项目地址： 点击跳转

---

0. 什么是单例模式？

1、这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
2、实现全局唯一访问对象的方式有以下几种： 懒汉、饿汉、双重校验锁、登记式/静态内部类、枚举
3、所有的实现方法均需要写空的构造函数，且为 private，防止该类不会被其他外部方法调用时实例化
4.LazyLoad，这种技巧很常用，就是指一个类包含某个成员变量，在类初始化的时候并不立即为该变量初始化一个实例，而是等到真正要使用到该变量的时候才初始化之。
由于LazyLoad可以有效的减少系统资源消耗，提高程序整体的性能，所以被广泛的使用，在大部分的单例模式实现中也是常存在。

---

1. 优缺点

优点：

1、内存里只有唯一一个实例，节省了内存消耗。
2、避免了对资源的多重占用

缺点：

1、没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

使用场景：

1、全局唯一实例
2、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等

应用实例：

1、一个班级只有一个班主任。
2、Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。
3、一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。

---

2. 举例说明

1. 懒汉式 StarvingSingleton

优点：

1. 性能最快
2. 第一次调用才会被初始化，节省了内存消耗

缺点：

1. 以时间换空间，线程不安全，因为没有枷锁 Synchronized

public class SluggardSingleton {
    //声明静态对象的时候就进行初始化
    private static SluggardSingleton mInstance = new SluggardSingleton();
    //私有构造方法，防止被实例化
    private SluggardSingleton() { }
    //外部获取实例
    public static SluggardSingleton getInstance(){
        return mInstance;
    }
}

想要懒汉式线程安全的话，可以在获取实例时枷锁判断即可 synchronized
同时代价就是效率变低，因为每次外部获取对象的时候就需要同步一次。

public class StarvingSingleton {
    //实例对象
    private static StarvingSingleton mInstance;
    //私有构造函数，防止外部方法对其进行实例化
    private StarvingSingleton(){}
    //外部获取实例对象
    public static synchronized StarvingSingleton getInstance(){
        if(mInstance == null){
            mInstance = new StarvingSingleton();
        }
        return mInstance;
    }
}

---

2. 饿汉式 SluggardSingleton

优点：

1. 没有枷锁，性能高
2. 线程安全，以空间换时间，它基于 classloader 机制避免了多线程的同步问题

缺点：

1. 类加载时就初始化，在整个项目中不一定会被用到，浪费内存

/**
 * 饿汉
 */
public class SluggardSingleton {
    //声明静态对象的时候就进行初始化
    private static SluggardSingleton mInstance = new SluggardSingleton();
    //私有构造方法，防止被实例化
    private SluggardSingleton() { }
    //外部获取实例
    public static SluggardSingleton getInstance(){
        return mInstance;
    }
}

---

3. DCL双重校验锁 Double Check Lock

优点：

1. 线程安全
2. 节省内存消耗，仅在被调用，且第一次调用的时候初始化
3. 性能高。有着双重检查机制，外部获取实例时，仅第一次需要同步。

缺点：

1. 在高并发的情况下，由于jvm存在乱序执行功能，在双重检查机制下，可能导致DCL失效。
   原因：
   1, 编译器优化了程序指令, 以加快cpu处理速度.
   2, 多核cpu动态调整指令顺序, 以加快并行运算能力.
   条件顺序：
   1.线程A调用DCL类，发现其mInstance == null，对其进行实例化。
   2.与此同时在高并发情况下， 由于编译器优化了程序指令, 允许对象在构造函数未调用完前, 将共享变量的引用指向部分构造的对象, 虽然对象未完全实例化, 但已经不为null了.
   3.线程B调用DCL类，发现其mInstance != null，则直接返回了mInstance，但实际上该类还没有完全实例化完毕。

jvm存在乱序执行
在实例化mInstance的时候jvm执行以下3个步骤。
1.在堆内存开辟内存空间。
2.在堆内存中实例化SingleTon里面的各个参数。
3.把对象指向堆内存空间。
由于jvm存在乱序执行功能，所以可能在2还没执行时就先执行了3，如果此时再被切换到线程B上，由于执行了3，INSTANCE 已经非空了，会被直接拿出来用，这样的话，就会出现异常。这个就是著名的DCL失效问题。
不过在JDK1.5之后，官方也发现了这个问题，故而具体化了volatile，即在JDK1.6及以后，只要定义为private volatile static SingleTon INSTANCE = null;就可解决DCL失效问题。volatile确保INSTANCE每次均在主内存中读取，这样虽然会牺牲一点效率，但也无伤大雅。

/**
 * 双检锁/双重校验锁
 */
public class DCLSingleton {
    //实例对象
    private static DCLSingleton mInstance;
    //私有构造函数，防止外部方法对其进行实例化
    private DCLSingleton(){}
    //外部获取实例对象
    public static DCLSingleton getInstance(){
        if(null == mInstance){
            synchronized (DCLSingleton.class){
                if(null == mInstance){
                    mInstance = new DCLSingleton();
                }
            }
        }
        return mInstance;
    }
}

如何解决上述的DCL失效问题？
我们可以用volatile对mInstance变量进行修饰
Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
简单的说就是让多线程访问变量的内存，而不是缓存

    private volatile static DCLSingleton mInstance;

那么随之带来的就是性能降低，但是解决了DCL的不是失效的问题。

---

4. 登记式/静态内部类 InternalClass

优点：

1. 线程安全，基于 classloader 机制避免了多线程的同步问题

缺点：

1. 由于内部是static 所以无法传入像是context上下文之类的

啊，这有点难以理解
描述：这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。
这种方式同样利用了 classloader 机制来保证初始化 instance 时只有一个线程，它跟第 3 种方式不同的是：第 3 种方式只要 Singleton 类被装载了，那么 instance 就会被实例化（没有达到 lazy loading 效果），而这种方式是 Singleton 类被装载了，instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance。想象一下，如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面，又不希望在 Singleton 类加载时就实例化，因为不能确保 Singleton 类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance 显然是不合适的。这个时候，这种方式相比饿汉方式就显得很合理。

/**
 * 静态内部类
 */
public class InternalClass {
    private static class InternalClassHolder{
        private static final InternalClass INSTANCE = new InternalClass();
    }
    //私有构造方法，防止被实例化
    private InternalClass(){}
    public static final InternalClass getInstance(){
        return InternalClassHolder.INSTANCE;
    }
}

---

5. 枚举 enumSingleton

优点：

1. 线程安全
2. 自动支持序列化机制
3. 防止反序列化重新创建新的对象，绝对防止多次实例化。
4. 不能通过 reflection attack 来调用私有构造方法。

public enum  enumSingleton {
    INSTANCE;
    public void whateverMethod() {
    }
}

经验之谈：一般情况下，不建议使用第 1 种和第 2 种懒汉方式，建议使用第 3 种饿汉方式。只有在要明确实现 lazy loading 效果时，才会使用第 5 种登记方式。如果涉及到反序列化创建对象时，可以尝试使用第 6 种枚举方式。如果有其他特殊的需求，可以考虑使用第 4 种双检锁方式。

---

3. Android技术生活交流

微信

---

[1]* 参考文章
[2]* 参考文章
[3]* 参考文章
[4]* 参考文章
[5]* 参考文章
[6]* 参考文章
[7]* 参考文章
[8]* 参考文章
[9]* 参考文章