有一些对象其实我们只需要一个，比如线程池、缓存、对话框、日志对象等，于是单例模式就出场了。
饿汉式
public class SingleDog {
// 为了不能在外部创建该类实例，需要把构造函数设置为私有
private SingleDog() {
}
private static final SingleDog mSingleDog = new SingleDog();
public static SingleDog getDog() {
return mSingleDog;
}
public static void eat() {
System.out.println("eat bone");
}
}
饿汉式是最简单的单例模式，缺点也很明显，就是不论用不用得到，都会创建实例。这对在这次程序运行中没用到该实例的情况是一种资源的浪费，于是就有了饱汉式。
饱汉式
public class SingleDog {
// 为了不能再外部创建该类实例，需要把构造函数设置为私有
private SingleDog() {
}
private static SingleDog mSingleDog;
public static SingleDog getDog() {
if (mSingleDog == null) {
mSingleDog = new SingleDog();
}
return mSingleDog;
}
public static void eat() {
System.out.println("Eat shit");
}
}
饱汉式是一种懒加载，当用到的时候再去创建，下次再用的时候因为不为null，就直接用，缺点也很明显，就是多线程的时候可能会创建多个对象，于是就有了同步锁。
饱汉式 同步锁
public class SingleDog {
// 为了不能在外部创建该类实例，需要把构造函数设置为私有
private SingleDog() {
}
private static SingleDog mSingleDog;
public static synchronized SingleDog getDog() {
if (mSingleDog == null) {
mSingleDog = new SingleDog();
}
return mSingleDog;
}
/*public static SingleDog getDog() {
synchronized (SingleDog.class) {
if (mSingleDog == null) {
mSingleDog = new SingleDog();
}
}
return mSingleDog;
}*/
public static void eat() {
System.out.println("Eat shit");
}
}
上面加了锁，可以保证不会创建多个，但是当我们已经创建了一个对象的时候，有多个线程去取该对象需要同步就没有必要的，这样做影响了性能，于是，就有了双重检查锁。
饱汉式 DCL双重检查锁
public class SingleDog {
// 为了不能在外部创建该类实例，需要把构造函数设置为私有
private SingleDog() {
}
private static SingleDog mSingleDog;
public static SingleDog getDog() {
if (mSingleDog == null) {
synchronized (SingleDog.class) {
if (mSingleDog == null) {
mSingleDog = new SingleDog();
}
}
}
return mSingleDog;
}
public static void eat() {
System.out.println("Eat shit");
}
}
双重检查锁在对象为空的时候，需要同步去创建，在创建时又判断了对象是不是为空，因此不会创建多个，而在对象不为空时，就直接返回对象，不需要同步。上面的写法看起来即可以保证一个对象，也能延迟加载。但其实最显而易见的错误是，SingleDog 对象初始化时的写操作与写入mSingleDog字段的操作可以是无序的。这样的话，如果某个线程调用getDog()可能看到mSingleDog字段指向了一个SingleDog 对象，但看到该对象里的字段值却是默认值，而不是在SingleDog 构造方法里设置的那些值。（假如SingleDog 有个字段是颜色，默认是白色，构造函数传入黄色，在多线程下，可能拿到了SingleDog 的实例颜色是白色的，因为SingleDog 已经指向了某一个对象了，所以不为空，但是由于还来不及写入黄色，就被另一个线程使用了，于是就白色了）
解决的办法是在声明单例对象时加上volatile private volatile static SingleDog mSingleDog;
当一个域声明为volatile类型后，编译器与运行时会监视这个变量：它是共享的，而且对它的操作不会与其他的内存操作一起被重排序。volatile变量不会缓存在寄存器或缓存在对其他处理器隐藏的地方。所以，读一个volatile类型的变量时，总会返回由某一线程所写入的最新值。
饱汉式 内部静态类
public class SingleDog {
// 为了不能再外部创建该类实例，需要把构造函数设置为私有
private SingleDog() {
}
public static SingleDog getDog() {
return InnerDog.mDog;
}
private static class InnerDog {
private static final SingleDog mDog = new SingleDog();
}
public static void eat() {
System.out.println("Eat shit");
}
}
由于内部静态类只会在被调用时才加载，且静态变量在声明时的赋值只会被执行一次，加上final 可以保证正在创建中的对象不能被其他线程访问到。因此这种内部静态类的单例实现是非常好的一种选择。
枚举单例
public enum SingleDog {
mSingleDog;
public static void eat() {
System.out.println("Eat shit");
}
}
利用枚举可以很简单的实现单例，不过android开发中，谷歌不推荐使用枚举，因为会比较占内存，所以这种方式就当做了解下。
扩展
双重检查锁定失效分析
Thread-safety with the Java final keyword
Android 中的 Enum 到底占多少内存？该如何用？
