设计模式-单例模式

     前记

           看了看Android源码设计模式，总得觉得应该把知识点罗列罗列，所以就想写些东西。同时做项目又把框架血崩了，重头再来。会在文章里加一点自己的理解。在这之前，先说说为什么要看设计模式。其实个人觉得，不太喜欢写很重复的代码。实现一个功能的代码，被无限次的写，感觉是一件比较蠢的事情。但是这个和好像和设计模式也没啥大关系。其实吧，还是有关系的。设计模式讲的更多的是对于一个功能，以如何的方式和框架去写代码。其实写代码就像写作文一样，给你一个题目，让你写作文。那么设计模式就比较像一个模版。（当然远远不止这些）。为了不重复写代码，必然涉及到自己造轮子，而轮子肯定是要符合兼容性强的特点，所以按照设计模式的方式来造轮子，可以很大程度达到要求。

        单例模式的定义

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

           

        单例模式的使用场景

               确定某个类在任何地方只有一个实例化对象，避免产生多个对象消耗过多资源的情况。例如：在一个android应用中，整个application的生命周期应当只有一个User对象。不能需要User时，就去实例化一次这个对象。

            

                 Note：单例模式中都是通过static标识唯一对象。意味着该对象一旦创建，任何地方操作了单例对象的数据都将直接反应到该单例身上。

        单例模式的UML图

        注：

            1.单例对象的构造方法都是私有的

            2.单例对象的获取实例化对象，是通过静态方法获取的。

            3.确保单例类的对象有且只有一个，尤其是在多线程环境下，即必须加锁

            4.确保单例类对象在反序列化时不会重新构建对象

          

       单例模式的实现分类：

                 懒汉式单例：

/*
 *   懒汉单例模式
 * */
public class LazySingleton {
    private static LazySingleton singleton;

    private LazySingleton() {
    }

    public static synchronized LazySingleton getInstance() {
        if (singleton == null) {
            singleton = new LazySingleton();
        }
        return singleton;
    }
}

                DCL单例模式:

/*
 *    Double Check Lock实现单例模式
 * */
public class DCLSingleton {
    private static DCLSingleton dclSingleton;

    private DCLSingleton() {
    }

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

              静态内部类单例模式：

import java.io.ObjectStreamException;

/*
*   静态内部类单例模式，最推荐的单例模式
* */
public class StaticInnerSingleton {
    private StaticInnerSingleton() {
    }

    public static StaticInnerSingleton getInstance() {
        return StaticInnerSingleHolder.sInstance;
    }

    private static class StaticInnerSingleHolder {
        private static final StaticInnerSingleton sInstance = new StaticInnerSingleton();
    }

    private Object readResolve() throws ObjectStreamException{
        return StaticInnerSingleHolder.sInstance;
    }
}

          使用容器实现单例模式：

/*
*
*   使用容器去管理单例模式，可以有效的管理所有的单例类
* */
public class SingletonManager {
    private static Map<String, Object> objectMap = new HashMap<String, Object>();

    private SingletonManager() {}

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

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

}

          饿汉式单例模式：

/*
*    饿汉式单例模式
* 
* */
public class HangrySingleton {
    private static HangrySingleton hangrySingleton = new HangrySingleton();
    private HangrySingleton(){
    }
    public static HangrySingleton getInstance(){
        return hangrySingleton;
    }
}

   总结：单例模式实现的目的就是为了在一个应用程序中，只能产生一个对象。所以记住这个条件，只要满足这个条件的地方，都可以使用单例模式，单例模式也是最简单的模式。不同的实现方式只是运用不同的考虑去实现这个功能，实现一个功能必然会引入其它的问题。