设计模式之单例模式

单例模式定义

确保某一个类之后一个实例，而且自行实例化并向整个系统提供服务。

单例模式使用场景

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

单例模UML类图

singleton.png

角色介绍：

Client - 客户端
Singleton - 单例类

实现单例模式主要注意的关键点：

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

通过将单例类的构造方法私有化，使得客户端代码不能通过new 的形式手动构造单例类的对象，单例类会暴露一个公有的静态方法，客户端需要调用这个静态方法获取到单例类的唯一对象，在获取这个单例类对象的过程中需要确保线程安全，即在多线程环境下构造单例类的对象也是有且只有一个，这也是单例模式实现中比较困难的地方。

单例类的实现

1.饿汉式单例

public class Singleton{

    /**
     * 饿汉式单例
     */
    private static final Singleton singleton = new Singleton();

    /**
     * 私有化构造方法
     */
    private Singleton() {

    }

    public static Singleton getSingleton() {
        return singleton;
    }
}

2.懒汉式单例

懒汉模式是声明一个静态对象，并且在用户第一次调用getSingleton() 时进行初始化，而上述饿汉模式是在声明静态对象时就已经初始化。懒汉模式实现：

public class LazySingleton {
    private static LazySingleton instance;
    private LazySingleton(){
    }

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

getInstance() 是用关键字synchronized 修饰，是一个同步方法，以确保多线程情况下单例类对象唯一性。但是每次调用getInstance() 时都会进行同步，这样会消耗不必要的资源，这也是懒汉式单例的最大问题。懒汉式单例模式优点是单例只有在使用时才会被初始化，在一定程度上节约了资源；缺点是第一次加载是需要及时进行实例化，反应稍慢。

3.Double Check Lock(DCL)实现单例

DCL 方式实现单例模式的优点是既能够在需要是才初始化，又能保证线程安全，且单例对象初始化后调用getInstance() 不进行同步锁。实现如下：

public class DCLSingleton {
    private static DCLSingleton singleton;

    private DCLSingleton() {
    }

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

DCL模式是使用最多的单例实现方式，它能够在需要是才实例化单例对象，并且能够保证对象的唯一性。

4.静态内部类单例模式

public class StaticInnerSingleton {
    public static StaticInnerSingleton getSingleton() {
        return SingletonHelp.SINGLRTON;
    }

    private static class SingletonHelp {
        private static final StaticInnerSingleton SINGLRTON = new StaticInnerSingleton();
    }
}

当第一次加载StaticInnerSingleton 类时并不会初始化SINGLRTON ，只有在第一次调用getSingleton() 时才会导致初始化。因此，第一次调用getSingleton()会导致虚拟机加载 SingletonHelp 类，这种方式不仅能保证线程安全，也能保证单例对象的唯一性，同时延迟了单例的实例化，所以推荐使用这种方式实现单例模式。

5.枚举单例

public enum EnumSingleton {
    INSINGLE;
}

写法简单是枚举单例的最大优点，枚举在Java 中与普通类一样，不仅能够有字段，还能够有自己的方法。最重要的是默认枚举实例的创建是线程安全的，并且任何情况下它都是一个单例。

6.使用容器实现单例

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

    private SingletonManager() {

    }

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

    public Object get(String key) {
        return objMap.get(key);
    }
}

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

总结

不管以那种方式实现单例模式，他们的核心都是将构造函数私有化，并且通过静态方法获取一个唯一的实例，在这个获取的过程中必须保证线程安全、防止反序列化导致重新生成实例对象等问题。但是由于客户端通常没有高并发的情况，因此，选择哪种方式实现并不会有太大影响。即便如此，出于效率考虑，推荐使用DCL方式和静态内部类方式。

优点

由于单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁的创建销毁时，而且创建和销毁时性能又无法优化，单例模式的优势就非常明显。
由于单例模式只生成一个实例，减少了系统的性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动是直接产生一个单例对象，然后永久驻留内存的方式解决。
单例模式可以避免对资源的多重占用，例如一个写文件操作，由于只有一个实例存在内存中，避免对同一资源文件的同时写操作。
单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如，可以设计一个单例类，负责所有数据表的映射处理。

缺点

单例模式一般没有接口，扩展很困难。
单例对象如果持有Context,那么很容易引发内存泄露，此时需要注意传递对象的Context最后是Application Context 。

设计模式之单例模式