记录几种单例模式写法。

饿汉模式(线程不安全）

    /**
     * 饿汉模式(线程不安全）
     * @return
     */
    private static Singleton getInstanceHungry() {
        mInstance = new Singleton();
        return mInstance;
    }

懒汉模式(线程不安全)

     /**
     * 懒汉模式(线程不安全)
     * @return
     */
    private static Singleton getInstanceLazy() {
        if (mInstance == null) {
            mInstance = new Singleton();
        }
        return mInstance;
    }

懒汉锁模式(线程安全)

    /**
     * 懒汉锁模式(线程安全)
     *
     * @return
     */
    private synchronized static Singleton getInstanceLazyThreadSafetyOne() {
        if (mInstance == null) {
            mInstance = new Singleton();
        }
        return mInstance;
    }

懒汉双重判断模式(线程安全)

    /**
     * volatile 修饰作用
     * 1.防止重排序
     * 2.值改变通知其他线程可见
     */
    private static volatile Singleton mInstance;

    /**
     * 懒汉双重判断模式(线程安全)
     *
     * @return
     */
    private synchronized static Singleton getInstanceLazyThreadSafetyTwo() {
        if (mInstance == null) {
            synchronized (Singleton.class) {
                if (mInstance == null) {
                    mInstance = new Singleton();
                }
            }
        }
        return mInstance;
    }

静态内部类模式

    /**
     * 静态内部类模式
     */
    public static class SingletonHolder {
        private static volatile Singleton mInstance;
    }

    public static Singleton getInstanceInnerclass() {
        return SingletonHolder.mInstance = new Singleton();
    }

容器管理模式

    /**
     * 容器管理模式
     */

    private static Map<String, Object> mSingleMap = new HashMap<>();


    static {
        mSingleMap.put("activity_manager", new Singleton());
    }

    public static Object getService(String serviceName) {
        return mSingleMap.get(serviceName);
    }

注：定义 private static volatile Singleton mInstance 带有 volatile 修饰主要是为了保证线程可见性和防止代码重排序的问题。