单例模式

单例模式简析

使用场景

1. 全局性的资源统一管理
2. 对象的创建和销毁开销比较大

实现基本思路

方案： 保证一个类只有一个实例，并提供一个一个对外的访问点。

常规方式：

1. 构造函数用private 修饰
2. 定义一个private static 的引用代表该对象
3. 对外提供public static 的方法来访问到这个对象。
4. 构造对象的过程中做好线程同步，避免产生多个对象。
5. 不要实现Serializable Cloneable接口。

分类

1. 创建过程是否依赖外部参数。
2. 懒加载和立即加载

懒加载的最基本的实现

public class Singleton {    private static Singleton INSTANCE;    public static synchronized Singleton getInstance(Object obj) {        if (INSTANCE == null) {            INSTANCE = new Singleton(obj);        }        return INSTANCE;    }    private Singleton(Object obj) {    }}

问题： 每次获取对象都要进行线程同步，性能损耗比较大。

懒加载的优化版本

public class Singleton2 {    private volatile static Singleton2 INSTANCE;    public static Singleton2 getInstance(Object obj) {        if (INSTANCE == null) {            synchronized (Singleton2.class) {                if (INSTANCE == null) {                    INSTANCE = new Singleton2(obj);                }            }        }        return INSTANCE;    }    private Singleton2(Object obj) {    }}

注意： 用双检锁（Double-checked locking)来优化对象的创建过程；用volatile来修饰对象。

volatile的作用

INSTANCE = new Singleton2(obj);
并不是一个原子操作，在jvm中这个语句会做下面三件事情：

1. 给INSTANCE分配内存
2. 调用构造函数来初始化成员变量。
3. 将INSTANCE 指向分配的内存空间。（执行完这个INSTANCE就是非null了）

编译器存在指令重排序的优化，第二步和第三步的顺序是不确定的，执行顺序可能是1-2-3,也可能是1-3-2 。如果是后者，并且出现3 执行完毕，2未完成初始化时，被另一个线程抢占了，此时直接返回INSTANCE，使用时会出现错误，而且这个错误很难被发现。这个问题并不在于创建了多个对象，而是在于可能会返回一个不可用的对象。

使用 volatile 的主要原因是：禁止指令重排序优化。也就是说，在 volatile 变量的赋值操作后面会有一个内存屏障（生成的汇编代码上），读操作不会被重排序到内存屏障之前。取操作必须在执行完 1-2-3 之后或者 1-3-2 之后，不存在执行到 1-3-2 然后取到值的情况。

立即加载的基本实现

public class Singleton{  private static final Singleton INSTANCE = new Singleton();  public static Singleton getInstance(){  return INSTANCE; }private Singleton(){ }}

注意：

1. 对象何时创建的? 类加载的时候创建的
2. 线程的同步如何保证？ 虚拟机加载类的过程是同步的。

类什么时候被加载？

1. 遇到new 、getstatic、 putstatic 或invokestatic 这四条字节码指令时，如果类没有进行初始化，则会触发初始化。生成这四种字节码指令的常见java代码场景是：new 关键字实例化对象；读取或者设置一个类的静态字段；调用一个类的静态方法。
2. 使用java.lang.reflect包中的方法对类执行反射调用，如果类没有执行初始化则需要触发其初始化。
3. 初始化一个类的时候，如果父类没有初始化则要先触发父类的初始化。
4. 虚拟机要启动的时候，用户需要指定一个要执行的主类（包含main方法的类），虚拟机会先初始化这个主类。

摘自《深入理解java虚拟机》

立即加载基本实现存在的问题

根据上面类加载的时机可以看到立即加载的基本实现存在一个问题：
如果单例类中存在其他的static的属性和方法，并且在调用getInstance之前就用到了这些属性和方法，那么便会触发对象的初始化，此时并不一定会需要这个对象。提前初始化可能会造成资源的浪费。

针对类加载时机的优化

public class Singleton{  private static class Holder{    private static final Singleton INSTANCE = new Singleton();} public static Singleton getInstance(){  return Holder.INSTANCE;}private Singleton(){}}

注：
这里采用静态内部类的方式，来将单例对象的构造放到了静态内部类的加载上来，只有外部调用getInstance时，采用触发对内部类的加载，实现了对构造对象的延迟。这种写法也比较简洁。

在Android 中使用单例的注意事项

单例对象如果需要持有Context对象，那一定要将转换为Application对象，因为单例对象本身是一个静态变量，持有Activity Service等Context 对象会造成内存泄露。

由于这个地方的context是个强引用，而且是被静态变量持有。在java中静态变量实在类被load的时候分配内存，在类被卸载的时候销毁。可以说static变量的生命周期伴随着进程的诞生和销毁。在Android系统中，当我们启动一个app的时候，系统启动一个进程加载一个Dalvik虚拟机实例，来负责类的加载和卸载以及GC，也就是说静态变量伴随了app进程的整个生命周期，由于上例中的instance持有了context，所以被传进来的activity（或者service或broadcast）自然没有办法得到释放，也就造成了内存泄露。

可以用context.getApplicationContext()方法来做一个转换，Application在Android程序中是一种单例式的存在，它伴随了整个应用的始终，所以使用Application的context不会造成内存泄露了。

参考文章：

1. http://wuchong.me/blog/2014/08/28/how-to-correctly-write-singleton-pattern/
2. http://www.jianshu.com/p/92f89da85cb2