Android设计模式之——单例模式

---

作用： 一个类提供一个可供全局调用的单一实例（全局仅有一个实例）。

分类： 常用的单例模式有：饿汉式、懒汉式、枚举、静态内部类。下面对他们进行详细介绍。

---

1、饿汉式

饿汉式就是在第一次调用该类的时候就创建该类的实例对象。如下：

public class Singleton {
    public Singleton() {
    }
    /**
     * 不管需不需要，直接初始化对象
     */
    private static Singleton singleInstance = new Singleton();
     /**
     * 使用时，直接调用即可
     */
    public Singleton getSingleInstance() {
        return singleInstance;
    }
}

缺点：不管使用不使用，都对该类进行了初始化，无法实现延迟加载（也称懒加载，延迟加载机制是为了避免一些无谓的性能开销而提出来的，所谓延迟加载就是当在真正需要数据的时候，才真正执行数据加载操作。）

2、懒汉式

懒汉式就是在需要的时候创建相应的实例，避免一些无谓的性能开销。如下：

public class Singleton {
    private static volatile Singleton singleInstance = null;//第四步
    /**
     * 使用时，直接调用即可
     */
    public Singleton getSingleInstance() {
        if (singleInstance == null) {//第一步
            synchronized (Singleton.class) {//第二步
                if (singleInstance == null) {
                    singleInstance = new Singleton();//第三步
                }
            }
        }
        return singleInstance;
    }
}

分析：
第一步：首先判断实例是否为空，避免每次调用都执行同步锁，减少不必要的开销
第二步：同步锁（监控当前只能有一个线程在执行该方法，通过锁定监视器与解锁控制下一个线程在本线程执行该步骤之后），好处：线程安全。
第三步：实例化对象，这里是线程不安全的。原因：这里可以分为三步：
（1）memory =allocate();          //给对象分配内存空间
（2）ctorInstance(memory);        //初始化对象（内存空间）
（3）singleInstance=memory；      //给singleInstance赋值（设置singleInstance指向的内存地址）
    （2）依赖于（1），（3）依赖于（1），但是（2）、（3）互相没有关系，所以根据JVM指令重排的规则，他们的执行顺序可能是（1）->（2）->（3），也可能是（1）->（3）->（2）。当多个线程同时执行该单例方法是，可能上一线程的（1）、（3）执行的了，下一个线程进入发现singleInstance不为空，直接返回了，这时候其实singleInstance并没有完全初始化，就会报错。这就需要第四步的volatile来解决问题。
第四步：volatile可以禁止JVM指令重排，同时保证不同线程对同一变量操作的可见性，当新线程对一变量就行修改后，该变量在其他线程立即见效。

好处：线程安全，效率高，延迟加载
缺点：别人可以通过反射调用自己的私有构造器；需要额外的工作(Serializable、transient、readResolve())来实现序列化，否则每次反序列化一个序列化的对象实例时都会创建一个新的实例。

3、枚举

枚举也是一种简单的单例模式，如下：

  public enum Singleton {

    instance;
    private String singleInstance;

    public String getSingleInstance() {
        return singleInstance;
    }

    public void setSingleInstance(String singleInstance) {
        this.singleInstance = singleInstance;
    }
}

优点：线程安全；防止反射强行调用构造器；自动序列化

4、静态内部类

 静态内部类也是一种线程安全的写法，如下：

public class Singleton {

    public Singleton() {
    }

    /**
     * 静态内部类中初始化对象
     */
    private static class InnerClass {
        private static Singleton singleton = new Singleton();
    }

    /**
     * 使用时直接调用
     *
     * @return
     */
    public static Singleton getSingleInstance() {
        return InnerClass.singleton;
    }
}

优点：线程安全，延迟加载（调用时初始化，减少内存开销）。
缺点：别人可以通过反射调用自己的私有构造器；需要额外的工作(Serializable、transient、readResolve())来实现序列化，否则每次反序列化一个序列化的对象实例时都会创建一个新的实例。