Android开发模式—单例模式

一、单例模式介绍
单例模式是应用最广的模式，在我们创建一个对象时为避免消耗过多的资源，我们便采用单例模式。
单例模式的定义是它应保证一个类仅有一个实例，同时这个类还必须提供访问该类的全局访问点。
实现单例模式有以下几个关键点：
1、其构造函数不对外开放，一般为private；
2、通过一个静态方法或者枚举返回单例对象；
3、确保单例对象有且只有一个，尤其是多线程的场景；
4、确保单例类对象的反序列化时不会重新创建对象；
二、单例模式的六种实现方式：
1、懒汉式（线程不安全）

package com.ceshi.single;/* * 懒汉模式，线程不安全 */public class SingletonA {    private static SingletonA instanceA = null;    private SingletonA() {    }    public static SingletonA getInstanceA() {        if (instanceA == null) {            return new SingletonA();        } else {            return instanceA;        }    }}

懒汉式（线程不安全）的单例模式分为三个部分：私有的构造方法，私有的全局静态变量，公有的静态方法。

其中起到重要作用的是静态修饰符static关键字，我们知道在程序中，任何变量或者代码都是在编译时由系统自动分配内存来存储的，而所谓静态就是指在编译后所分配的内存会一直存在，直到程序退出内存才会释放这个空间，因此也就保证了单例类的实例一旦创建，便不会被系统回收，除非手动设置为null。

2、懒汉式（线程安全）

package com.ceshi.single;/* * 懒汉模式、线程安全 */public class SingletonB {    private static SingletonB instanceB=null;    private SingletonB(){    }    public static synchronized SingletonB getInstanceB(){        if (instanceB==null) {            return new SingletonB();        }else {            return instanceB;        }    }}

同步的意思是当两个并发线程访问同一个类中的这个synchronized同步方法时， 一个时间内只能有一个线程得到执行，另一个线程必须等待当前线程执行完才能执行，因此同步方法使得线程安全，保证了单例只有唯一个实例。

但是它的缺点在于每次调用getInstance（）都进行同步，造成了不必要的同步开销。这种模式一般不建议使用。

3、恶汉模式（线程安全）

package com.ceshi.single;/* * 恶汉模式 */public class SingletonC {    //创建一个静态的对象供系统使用，所以天生就是安全的。    private static SingletonC instanceC=new SingletonC();    private SingletonC(){    }    public static SingletonC getInstanceC(){        return instanceC;    }}

4、DCL双重校验模式：

package com.ceshi.single;/* * DCL双检校验模式 */public class SingletonD {    private static SingletonD instanceD=null;    private SingletonD(){    }    public static SingletonD getInstanceD(){        if (instanceD==null) {            synchronized (SingletonD.class) {                if (instanceD==null) {                    return new SingletonD();                }            }        }        return instanceD;    }}

这种模式的亮点在于getInstance（）方法上，其中对singleton 进行了两次判断是否空，第一层判断是为了避免不必要的同步，第二层的判断是为了在null的情况下才创建实例。具体我们来分析一下：

假设线程A执行到了singleton = new Singleton(); 语句，这里看起来是一句代码，但是它并不是一个原子操作，这句代码最终会被编译成多条汇编指令，它大致会做三件事情：
（a）给Singleton的实例分配内存
（b）调用Singleton（）的构造函数，初始化成员字段；
（c）将singleton对象指向分配的内存空间（即singleton不为空了）；

但是由于Java编译器允许处理器乱序执行，以及在jdk1.5之前，JMM（Java Memory Model：java内存模型）中Cache、寄存器、到主内存的回写顺序规定，上面的步骤b 步骤c的执行顺序是不保证了。也就是说执行顺序可能是a-b-c，也可能是a-c-b,如果是后者的指向顺序，并且恰恰在c执行完毕，b尚未执行时，被切换到线程B中，这时候因为singleton在线程A中执行了步骤c了，已经非空了，所以，线程B直接就取走了singleton，再使用时就会出错。这就是DCL失效问题。
但是在JDK1.5之后，官方给出了volatile关键字，将singleton定义的代码改成：

private volatile static Singleton singleton;  //使用volatile 关键字

5、静态内部类：

package com.ceshi.single;public class SingletonE {    /*     * 内部类实现单利模式     * 延迟加载，减少内存开销     *      */    private static class SingletonHolder{        private static SingletonE instancE=new SingletonE();    }    /*     * 私有构造     */    private SingletonE(){    }    public static SingletonE getInstanceE(){        return SingletonHolder.instancE;    }}

优点：延迟加载，线程安全（java中class加载时互斥的），也减少了内存消耗。

6、枚举方法：

package com.ceshi.single;import java.io.Serializable;/* * 枚举实现 */public enum SingletonF implements Serializable {    /**     * 1.从Java1.5开始支持; 2.无偿提供序列化机制; 3.绝对防止多次实例化，即使在面对复杂的序列化或者反射攻击的时候;     */    INSTANCE;    private String others;    public String getOthers() {        return others;    }    public void setOthers(String others) {        this.others = others;    }    /*     * 调用 SingletonF singleton = SingletonF.INSTANCE;     */}

枚举单例模式最大的优点就是写法简单，枚举在java中与普通的类是一样的，不仅能够有字段，还能够有自己的方法，最重要的是默认枚举实例是线程安全的，并且在任何情况下，它都是一个单例。即使是在反序列化的过程，枚举单例也不会重新生成新的实例。