单例模式 singleton pattern

有一些对象其实我们只需要一个，比如线程池、缓存、对话框、日志对象等，于是单例模式就出场了。

单例模式结构图.png

饿汉式

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 到底占多少内存？该如何用？