Brandon-Winterfell's Blog

单例模式

发表于 | 分类于 | | 阅读次数

实现的核心在于将类的构造方法私有化,使得外部程序不能通过构造函数来构造改类的对象，而该类通过 一个静态方法 返回一个静态对象。

为什么要使用单例模式

确保某个类有且只有一个对象的场景，避免产生多个对象消耗过多的资源，或者某种类型的对象只应该有且只有一个。例如，创建一个对象需要消耗的资源过多，如要访问IO和数据库等资源。许多时候整个系统只需要拥有一个全局对象，这样有利于我们协调系统整体的行为。如在一个应用中，应该只有一个ImageLoader实例，这个ImageLoader中又含有线程池、缓存系统、网络请求等，很消耗资源，因此，没有理由让它构造多个实例。

单例模式的关键点

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

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

实现

饿汉模式

public class Singleton {

    // 这个对象是一个静态对象，声明的时候就初始化，这就保证了该对象的唯一性
    private static final Singleton sInstance = new Singleton();

    // 构造函数私有
    private Singleton() {

    }

    // 公有的静态函数，对外暴露获取单例对象的接口
    public static Singleton getInstance() {
        return sInstance;
    }

}

该类不能通过 new 的形式构造对象，只能通过 getInstance 函数来获取，而这个instance对象是静态对象，并且在声明的时候就已经初始化，这就保证了该对象的唯一性。

懒汉模式

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

public class Singleton {

    // 是一个静态对象,私有的
    private static Singleton sInstance;

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

    }

    // 公有的静态方法，返回单例对象
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            sInstance = new Singleton();        
        }
        return sInstance;
    }

}

这里的getInstance()方法中添加了synchronized关键字，也就是说这是一个同步方法，这就是上面所说的在多线程情况下保证单例对象唯一性的手段。

优点就是该单例对象只有在使用的时候才会被实例化；这里有一个不足就是，即使instance对象已经被初始化了，每次调用getInstance方法都会进行同步，造成不必要的同步开销，这也是懒汉单例模式存在的最大问题。

Double Check Lock （DCL）实现单例

public class Singleton {

    // 静态、私有单例对象，应该加上volatile关键字
    private static Singleton sInstance = null;

    // 私有的构造函数
    private Singleton() {

    }

    // 公有的静态方法获取该单例对象
    public static Singleton getInstance() {
        if (sInstance == null) {
            synchronized(Singleton.class) {
                if (sInstance == null) {
                    sInstance = new Singleton();
                }
            }
        }
        return sInstance;
    }
}

DCL实现方式的优点是既能够在需要时（第一次使用的时候）才初始化单例，又能够保证线程安全，且单例对象初始化后调用getInstance不进行同步锁，没有多余的同步。这种方式一般满足需求。

getInstance方法中对instance进行了两次判空：第一层判断主要是为了避免不必要的同步，第二层的判断则是为了在null的情况下创建实例。

分析：

假设线程A执行到sInstance = new Singleton()语句，这里看起来只是一句代码，但是实际上它并不是一个原子操作，这句代码最终会被编译成多条汇编指令，它大致做了3件事请：

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

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

为什么会切换到线程B：线程A的时间片用完了，线程调用器就会重新调度线程，选择一个最高优先级的线程去执行，或者线程们的优先级都一样，那就随机选取一个线程去运行。

在JDK1.5之后，SUN官方已经注意到这种问题，调整了JVM，具体化了volatile关键字，（TODO volatile关键字的含义）因此，如果JDK是1.5或之后的版本，只需要将sInstance的定义改成private volatile static Singleton sInstance = null就可以保证sInstance对象每次都是从主内存中读取，就可以使用DCL的写法来完成单例模式。当然，volatile或多或少也会影响到性能，单考虑到程序的正确性，牺牲这点性能还是值得的。

静态内部类单例模式

public class Singleton {
    // 私有的构造方法 
    private Singleton() {

    }

    // 公有的静态方法
    public static Singleton getInstance() {

        return SingletonHolder.sInstance;
    }

    // 静态内部类
    private static class SingletonHolder {
        // 修饰符 私有 静态 final
        private static final Singleton sInstance = new Singleton();
    }
}

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

枚举单例

public enum SingletonEnum {

    INSTANCE;

    public void doSomething() {

    }

}

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

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

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

private Object readResolve() throws ObjectStreamException () {

    return sInstance;
}

也就是在readResolve方法中将sInstance对象返回，而不是默认的重新生成一个新的对象。而对于枚举，并不存在这个问题，因为即使反序列化它也不会重新生成新的实例。

使用容器实现单例模式

public class SingletonManager {

    // static的Map容器，用来装单例对象
    private static Map<String, Object> objMap = new HashMap<String, Object>();

    // 私有的构造方法
    private SingletonManager() {

    }

    // 将单例对象装进容器里 静态方法
    public static void registerService(String key, Object instance) {
        if (!objMap.containsKey(key)) {
            objMap.put(key, instance);
        }
    }

    // 根据key拿到对应的那个单例对象 静态方法
    public static Object getService(String key) {

        return objMap.get(key);
    }
}

在程序的初始，将多种单例类型注入到一个统一的管理类中，在使用时根据key获取对象对应类型的对象。

这种方式使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行操作，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。

总结

不管以哪种形式实现单例模式，它们的核心原理都是将构造函数私有化，并且通过静态方法获取一个唯一的实例，在这个获取的过程中必须保证线程安全、防止反序列化导致重新生成实例对象等问题。选择哪种实现方式取决于项目本身，如是否是复杂的并发环境、JDK版本是否过低、单例对象的资源消耗等。

要准确的手写出来，还是不容易的。久不用就忘了，上次个笔试手写单例，我原来以为闭着眼睛都能写出来的了。结果双重检验锁方式还是漏了点东西，static关键字，volatile关键字，还有synchronized(Singleton.class)锁这个类而不是synchronized(this)（这个还跟关键字static有关,类级别、对象级别）。而静态内部类忘了怎么写。

内容来源：《Android源码设计模式 解析与实战》