天天看点
返回

单例设计模式总结单例模式代码模板

单例模式

单例模式应该是作为开发最早接触的设计模式了。确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例就是单例模式。

什么时候需要使用单例呢？

确保某个类有且只有一个对象的场景，避免产生多个对象消耗过多的资源，或当创建一个对象需要消耗的资源过多时，如访问IO和数据库等资源。

实现单例的关键点

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

实现方式

饿汉式单例 

public class EagerSingleton {
    private static final EagerSingleton sInstance = new EagerSingleton();

    private EagerSingleton() {
    }

    public static EagerSingleton getInstance() {
        return sInstance;
    }
}
复制代码

饿汉式是最简单的单例，它的实例在系统启动的时候就会初始化，并且是线程安全，因为在访问之前就初始化好了，不存在同步的问题。但是这样也代表着，如果这个单例并不一定会用到，或者只有特定的地方才会使用，并且消耗的资源很多，那么一开始就初始化实例并不是一个聪明的举动，代表着资源的浪费。

懒汉式单例 

public class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton() {
    }

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

懒汉式会在首次调用getInstance()方法的时候初始化实例，并且synchronized修饰方法，确保了多线程情况下的单例对象唯一性。但这也带来了问题，即instance在初始化之后的每次调用getInstance()都会进行同步，这样会消耗不必要的资源。

Double Check Lock (DCL)单例 

public class DCLSingleton {
    private static DCLSingleton instance;
    
    private DCLSingleton() {
    }
    
    public static DCLSingleton getInstance() {
        if (instance == null) {
            synchronized (DCLSingleton.class) {
                if (instance == null) {
                    instance = new DCLSingleton();
                }
            }
        }
        return instance;
    }
}
复制代码

可以看到DCL其实与懒汉式类似，只是在getInstance方法上做了优化，可以看到getInstance方法中对instance进行了两次判空：第一层判断主要是为了避免不必要的同步，第二层的判断则是为了在null的情况下创建实例。

但是DCL单例也有隐藏的隐患。

假设线程A执行到

instance = new DCLSingleton();

语句，这里看起来是一句代码，但实际上它并不是一个原子操作，这句代码最终会被编译成多条汇编指令，它大致做了3件事情：

  1. 给DCLSingleton实例分配内存；
  2. 调用DCLSingleton()的构造函数，初始化成员字段；
  3. 将instance对象指向分配的内存空间（此时instance就不是null了）。

但是，由于Java编译器允许处理器乱序执行，以及JDK1.5之前JVM（Java内存模型）中Cache、寄存器到主内存回写顺序的规定，上面的2和3的顺序是无法保证的。也就是说，执行顺序可能是1-2-3也可能是1-3-2.如果是后者，并且在3执行完毕，2未执行之前，被切换到线程B上，这时候instance因为已经在线程A内执行过了3，instance已经是非空了，所以，线程B直接取走instance，在使用时就会出错，这就是DCL失效问题，而且这种难以追踪难以重现的错误很可能会隐藏很久。

在JDK1.5之后，SUN官方已经注意到这种问题，调整了JVM ，具体化了volatile关键字，因此，如果是1.5之后的版本，只需要将instance定义改成

private volatile static DCLSingleton instance;

就可以保证instance对象每次都是从主内存中读取，就可以使用DCL的写法来完成单例模式。当然，volatile或多或少也会影响性能。

静态内部类单例 

public class StaticSingleton {
    private StaticSingleton() {
    }

    public static StaticSingleton getInstance() {
        return SingletonHolder.sInstance;
    }

    private static class SingletonHolder {
        private static final StaticSingleton sInstance = new StaticSingleton();
    }
}
复制代码

当第一次加载StaticSingleton类时并不会初始化sInstance，只有在第一次调用getInstance方法时才会导致sInstance被初始化。因此，第一次调用getInstance方法或导致虚拟机加载SingletonHolder类，这种方式不仅能够确保线程安全，也能够保证单例对象的唯一性，同时也延迟了单例的实例化。这也是本人最喜欢的单例方式。

使用容器实现单例 

public class SingletonManager {
    private static Map<String, Object> objectMap = new HashMap<>();
    
    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);
    }
}
复制代码

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

在Android系统中的各种Service就是通过这种方式管理的单例。

ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
复制代码

枚举单例 

public enum EnumSingleton {
    INSTANCE;

    public void doSomething() {
        System.out.println("do sth.");
    }
}
复制代码

没错，就是枚举！

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

为什么这么说呢？上面几种单例的实现中，在一个情况下他们会出现重新创建对象的情况，那就是反序列化。

实现序列化的单例

通过序列化可以将一个单例的实例对象写到磁盘，然后在读回来，从而有效地获得一个实例。即使构造函数是私有的，反序列化时依然可以通过特殊的途径去创建类的一个新实例，相当于调用该类的构造函数。反序列化操作提供了一个很特别的钩子函数，类中具有一个私有的、被实例化的方法readResolve()，这个方法可以让开发人员控制对象的反序列化。

也就是说如果你的单例实现了Serializable接口，那么为了保证单例也必须添加readResolve()方法控制反序列化返回的对象。例如下面这个例子：

public class EagerSingleton implements Serializable {
    private static final EagerSingleton sInstance = new EagerSingleton();

    private EagerSingleton() {
    }

    public static EagerSingleton getInstance() {
        return sInstance;
    }

    //支持序列化的单例
    private Object readResolve() throws ObjectStreamException {
        return sInstance;
    }
}
复制代码

代码模板

在as中，我们可以为单例设置代码模板，加快我们单例类的编写。

在设置中找到Live Templates

点击标记1的加号一次添加分类以及模板，例如我新建的分类myTemplate以及模板singleton（标记2）。

标记3的位置是提示的前提，也就是说这里设置了什么内容，你在代码中敲出同样内容后，就会提示代码模板：

标记4的区域是模板的内容，这里我选用的静态内部类的单例模式：

private $CLASS$(){
}

public static $CLASS$ getInstance(){
    return SingletonHolder.sInstance;
}

private static class SingletonHolder{
    private static final $CLASS$ sInstance = new $CLASS$();
}
复制代码

$CLASS$

可以被动态替换为所在的类名，当我在一个新的类中输入singleton，并选择了模板，就会生成这些代码。

标记5 可以选择模板提示的范围，这里我们选择在Java的代码中生效：

最后点击确定保存模板。接下来就可以在代码中敲出singleton选择提示的模板快速生成单例的代码。

设计模式 java 移动开发
上一篇: Unix的特点
下一篇: 关于fatal error C1853: 'Debug/TrafficDet.pch' is not a precompiled header file created with this compiler

继续阅读