设计模式：单例模式

简介

单例模式使得一个类的实例是唯一的，外部对它的访问都针对同一个对象。
单例模式的使用可以是业务上的原因，比如一个User对象需要全局唯一，或者是性能上的考虑，避免创建代价较高的对象反复实例化。

实现方式

• 饿汉式：性能不是问题时，且对象一定需要被实例化，线程安全

public class User {
    private static final User ourInstance = new User();

    public static User getInstance() {
        return ourInstance;
    }

    private User() {
    }
}

• 双重锁定
  线程安全，较高的性能，无需每次都加锁

public class User {
    private static volatile User ourInstance;

    public static User getInstance() {
        if (ourInstance == null) {
            synchronized (User.class) {
                if (ourInstance == null) {
                    ourInstance = new User();
                }
            }
        }
        return ourInstance;
    }

    private User() {
    }
}

• 静态内部类
  仅在第一次调用getInstance()时，发生实例化，而且字段初始化语句是线程安全的。

public class User {
   
    public static User getInstance() {
        return Holder.ourInstance;
    }

    private static class Holder {
        private static User ourInstance = new User();
    }

    private User() {
    }
}

• 单例集合
  可以使用一个HashMap等集合来维护需要的单例对象，初始化放在程序启动时或其它合适的时机。此时可以根据对象的不同方面对它进行分类，而且最终得到同一个实例。
  此时使用到的类型本身无需是单例的，这种形式处理app中会用到的若干个全局对象时蛮合适。

• 单例数据结构
  像android中就有一个下面的帮助类，它为目标类型T进行惰性初始化。

public abstract class Singleton<T> {
    private T mInstance;

    protected abstract T create();

    public final T get() {
        synchronized (this) {
            if (mInstance == null) {
                mInstance = create();
            }
            return mInstance;
        }
    }
}

使用：

private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {
    protected IActivityManager create() {
        IBinder b = ServiceManager.getService("activity");
        if (false) {
            Log.v("ActivityManager", "default service binder = " + b);
        }
        IActivityManager am = asInterface(b);
        if (false) {
            Log.v("ActivityManager", "default service = " + am);
        }
        return am;
    }
};

好处就是对无法修改的目标类型进行单例化，好像也没多大卵用。

• 枚举方式
  线程安全，性能可以，就是怪怪的。

public enum User{  
    INSTANCE;  
} 

补充

• clone和单例是冲突的
• 反射可以破坏单例，只要加一个静态的flag来标识是否创建过对象就可以了，反射还得走构造函数。
• 反序列化：增加方法readResolve()：

public Object readResolve(){
   return getInstance();
}