单利设计模式

单利模式的介绍

单利模式是应用最广的模式之一，也可能是很多初级工程师唯一会使用的设计模式。在应用这个模式时，单利对象的类必须保证只有一个实例存在。许多情况下整个系统只需要拥有一个全局对象，这样有利于我们协调系统整体的行为，降低支援的消耗。

定义

确保只有一个实例，而且自行实例化并向这个系统提供这个实例。

单例模式使用场景(套路)

确保某个类有且只有一个对象的场景，避免产生多个对象消耗过多的资源，或者某种类型的对象应该有且只有一个。例如，创建一个对象需要消耗的资源过多，如访问IO和数据库等资源，这时候就要考虑使用单利模式。

单例模式UML类图

单利模式.png

角色介绍：
（1）Client----高层客户端；
（2）Singleton----单利类
实现单例模式主要有如下几个关键点：

• 构造函数不对外开放，一般为private
• 通过一个静态方法或者枚举返回单利类对象
• 确保单利类的对象有且只有一个，尤其是在多线程环境下
• 确保单利类对象在反序列化是不会重新构建对象

注意：
通过将单利类的构造函数私有化，使得客户端代码不能通过new的形式手动构造单利类的对象。单利类会暴露一个共有静态方法，客户端需要调用这个静态方法获取到单利类的唯一对象，在获取这个单利对象的过程中需要确保线程安全，即在多线程环境下构造单利类的对象也是有且只有一个。

单利类的几种实现方式

1：饿汉式

public class SingleTon {
    public static final SingleTon mInstance = new SingleTon();

    //构造函数私有
    private SingleTon() {
    }
    //公有的静态函数，对外暴露获取单利对象的接口
    public static SingleTon getInstance(){
        return mInstance;
    }
}

从上述代码可知，SingleTon 类不能通过new的形式构造对象，只能通过
SingleTon.getInstance()函数获取，而这个对象时静态对象，并且在声明的时候就已经初始化，这就保证了SingleTon对象的唯一性。

2：懒汉式
懒汉式是声明一个静态对象，并且在用户第一次调用getInstance()时进行初始化

public class SingleTon {
    public static SingleTon mInstance ;

    //构造函数私有
    private SingleTon() {
    }
    //公有的静态函数，对外暴露获取单利对象的接口
    public static synchronized SingleTon getInstance(){
        if (mInstance==null){
            mInstance=new SingleTon();
        }
        return mInstance;
    }
}

3：Double Check Lock(DCL)实现单利

public class SingleTon {
    public static SingleTon mInstance;

    //构造函数私有
    private SingleTon() {
    }

    //公有的静态函数，对外暴露获取单利对象的接口
    public static synchronized SingleTon getInstance() {
        if (mInstance == null) {
            synchronized (SingleTon.class) {
                if (mInstance == null) {
                    mInstance = new SingleTon();
                }
            }
        }
        return mInstance;
    }
}

双重锁的亮点在于双重判断，相对于懒汉式的写法，减少了没必要的同步判断。

• 第一层判断主要是避免不必要的同步
• 第二层判断是为了在null的情况下创建实例

那么DCL模式就没有缺点？
假设线程A执行到mInstance = new SingleTon();语句，这里看起来是一句代码，但实际上它并不是一个原子操作，这段代码最终会被变异成多条汇编指令，大致做了三件事：
(1)给mInstance 实例分配内存；
(2)调用Singleton()的构造函数，初始化成员字段
(3)将mInstace对象指向分配的内存空间（此时mInstace就不是null了）
如果指令按照顺序执行倒也无妨，但在jdk1.5之前，JVM为了优化指令，提高程序运行效率，允许指令重排序上面的执行顺序有可能是这样的
(a)给mInstance 实例分配内存；
(b)将mInstace对象指向分配的内存空间（此时mInstace就不是null了）
(c)调用Singleton()的构造函数，初始化成员字段
如果是后者，并且执行完了b操作(c操作之前)，被切换到线程B，这时候mInstance 因为已经在线程A执行了b操作，mInstance 不为空，所以线程B直接取走mInstance ，在使用时就会出错，这就是DCL失效问题。
具体来说就是synchronized虽然保证了线程的原子性（即synchronized块中的语句要么全部执行，要么一条也不执行），但单条语句编译后形成的指令并不是一个原子操作（即可能该条语句的部分指令未得到执行，就被切换到另一个线程了）。
根据以上分析可知，解决这个问题的方法是：禁止指令重排序优化，即使用volatile变量。

public class SingleTon {
    public volatile static SingleTon mInstance;

    //构造函数私有
    private SingleTon() {
    }

    //公有的静态函数，对外暴露获取单利对象的接口
    public static synchronized SingleTon getInstance() {
        if (mInstance == null) {
            synchronized (SingleTon.class) {
                if (mInstance == null) {
                    mInstance = new SingleTon();
                }
            }
        }
        return mInstance;
    }
}

4：静态内部类单利模式

public class SingleTon {
    public volatile static SingleTon mInstance;

    //构造函数私有
    private SingleTon() {
    }

    public static SingleTon getInstance() {
        return SingletonHolder.mInstance;
    }

    /**
     * 静态内部类
     */
    private static class SingletonHolder {
        private static final SingleTon mInstance = new SingleTon();
    }
}

当第一次加在Singleton类时并不会初始化mInstace，只有在第一次调用
SingleTon.getInstance()方法时才会导致mInstace被初始化。因此，第一次调用getInstace()方法会导致虚拟机加在SingletonHolder类。这种方式不仅能够确保线程安全，也能保证单利对象的唯一性，同时也延迟了单利的实例化，所以这是土建使用的单利模式实现方式。

5：枚举单利

public enum  SingleTon {
    INSTANCE;
    public void doSomething(){
        System.out.println("do sth...");
    }
}

有点：

• 实现方式简单
• 默认情况下枚举实例的创建是线程安全的，并且在任何情况下它都是一个单利。

6：使用容器实现单利模式

public class SingletonManager {
    private static Map<String, Object> objectMap = new HashMap<>();

    private SingletonManager() {
    }

    public static void registerServiec(String key, Object instance) {
        if (!objectMap.containsKey(key)) {
            objectMap.put(key, instance);
        }
    }

    public static Object getService(String key) {
        return objectMap.get(key);
    }
}

在程序的初始，将多种单利类型注入到一个统一的管理类中，在使用时根据key获取对象对应类型的对象。这种方式使得我们可以管理多种类型的单利，并且在使用时可以通过统一的接口进行后去操作，降低用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。

单利模式的实例--Activity的管理

public class ActivityManager {
    private static volatile ActivityManager mInstance;
    // 集合用谁 List LinkedList Stack  ?? 删除和添加比较多
    private Stack<Activity> mActivities;

    private ActivityManager(){
        mActivities = new Stack<>();
    }

    // 虽说解决了线程安全的问题，但是又会出现效率的问题，
    // 即保证线程的安全同是效率也是比较高的
    // 这种方式其实还是会有问题？
    public static ActivityManager getInstance() {
        if (mInstance == null) {
            synchronized (ActivityManager.class) {
                if (mInstance == null) {
                    mInstance = new ActivityManager();
                }
            }
        }
        return mInstance;
    }

    /**
     * 添加统一管理
     * @param activity
     */
    public void attach(Activity activity){
        mActivities.add(activity);
    }

    /**
     * 移除解绑 - 防止内存泄漏
     * @param detachActivity
     */
    public void detach(Activity detachActivity){
        // for 去移除有没有问题？ 一边循环一边移除会出问题 ，
        // 既然这个写法有问题，自己又想不到什么解决方法，参考一下别人怎么写的
        /*for (Activity activity : mActivities) {
            if(activity == detachActivity){
                mActivities.remove(activity);
            }
        }*/
        int size = mActivities.size();
        for (int i = 0; i < size; i++) {
            Activity activity = mActivities.get(i);
            if (activity == detachActivity) {
                mActivities.remove(i);
                i--;
                size--;
            }
        }
    }

    /**
     * 关闭当前的 Activity
     * @param finishActivity
     */
    public void finish(Activity finishActivity){
        // for 去移除有没有问题？
        /*for (Activity activity : mActivities) {
            if(activity == finishActivity){
                mActivities.remove(activity);
                activity.finish();
            }
        }
*/
        int size = mActivities.size();
        for (int i = 0; i < size; i++) {
            Activity activity = mActivities.get(i);
            if (activity == finishActivity) {
                mActivities.remove(i);
                activity.finish();
                i--;
                size--;
            }
        }
    }

    /**
     * 根据Activity的类名关闭 Activity
     */
    public void finish(Class<? extends Activity> activityClass){
        // for 去移除有没有问题？
        /*for (Activity activity : mActivities) {
            if(activity.getClass().getCanonicalName().equals(activityClass.getCanonicalName())){
                mActivities.remove(activity);
                activity.finish();
            }
        }*/

        int size = mActivities.size();
        for (int i = 0; i < size; i++) {
            Activity activity = mActivities.get(i);
            if (activity.getClass().getCanonicalName().equals(activityClass.getCanonicalName())) {
                mActivities.remove(i);
                activity.finish();
                i--;
                size--;
            }
        }
    }

    /**
     * 退出整个应用
     */
    public void exitApplication(){

    }

    /**
     * 获取当前的Activity（最前面）
     * @return
     */
    public Activity currentActivity(){
        return mActivities.lastElement();
    }
}