---

点击进入我的博客

2.4 单例模式

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

2.4.1 单例模式细节

核心代码

私有化构造方法！

解决什么问题

• 保证一个类仅有一个实例，并提供一个访问它的全局访问点。
• 主要解决一个全局使用的类频繁地创建与销毁的问题。

单例模式的应用

1. 属性文件
2. Java.lang.Runtime对象

单例模式优点

1. 在内存中只有一个实例，减少内存开支，特别是一个对象需要频繁地创建销毁时。
2. 单例模式可以避免对资源的多重占用，例如一个写文件操作，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作。
3. 单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如，可以设计一个单例类，负责所有数据表的映射处理。

单例模式缺点

1. 由于私有化了构造方法，所以不能继承
2. 与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。
3. 特别要注意单例对象如果持有Context，那么容易引发内存泄漏，此时需要注意传递给单例对象的context，最好是Application Context

2.4.2 饿汉式与懒汉式

饿汉式

• 加载类的时候比较慢
• 运行时获得对象的速度比较快
• 它从加载到应用结束会一直占用资源。

class EagerSingleton {
    // 创建单例类对象
    private static EagerSingleton instance = new EagerSingleton();
    // 构造方法私有化
    private EagerSingleton() {}
    // 获取可用对象
    public static EagerSingleton getInstance() {
        return instance;
    }
}

懒汉式

• 是运行时获得对象的速度比较慢
• 加载类的时候比较快
• 它在整个应用的生命周期只有一部分时间在占用资源。

class LazySingleton {
    // 声明单例类对象
    private static LazySingleton instance;
    // 构造方法私有化
    private LazySingleton() {}
    // 获取可用对象
    public static synchronized LazySingleton getInstance() {
        if(null == instance) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

2.4.3 懒汉式与双重检查成例

1. 由于2.4.2懒汉式代码中，直接对整个getInstance()方法进行了同步处理，可能会导致一些性能问题，于是有了下面的改进方法，通过双重检查和同步代码块的形式来处理懒汉式的并发问题。但要注意的是，这在Java语言中可能是问题的，之所以是可能有问题，是因为不同Java版本的内存模型不同。
2. 在第一次检查时，可能会有多个线程同时到达(1)处。假设线程1和线程2都到达(1)进行第一次检查，此时instance为null，两个线程都通过第一次检查
3. 然后由于同步代码块加锁，只能有一个线程获取锁。线程1获取锁并向下继续执行，此时instance仍然为null，于是执行(5)初始化instance = new Singleton()，然后线程1执行完毕释放锁。
4. 然后线程2获取锁，此时第二次检查判断instance不为null，所以线程2不会进行初始化，直接退出，返回已经初始化好的instance。
5. 以上步骤听起来是没有问题的，但问题出在instance = new Singleton()这一句话并不是原子操作！

class Singleton {
    private static Singleton instance;
    private Singleton() {}

    public static Singleton getInstance() throws Exception {
        if(null == instance) { // (1)第一次检查
            // (2)这里会有多个线程同时到达
            synchronized(Singleton.class) { // 同步代码块加锁
                // (3)此处只能是单线程
                if (null == instance) { // (4)第二次检查
                    instance = new Singleton(); // (5)初始化instance
                }
            }
        }
        return instance;
    }
}

问题出现的原因：无序写入

为展示问题出现的原因，假设代码行instance =new Singleton();执行了下列伪代码：

mem = allocate();             // (1)为单例对象分配内存空间.
instance = mem;               // (2)注意，instance引用现在已经不是null，但还未初始化
ctorSingleton(instance);      // (3)为单例对象通过instance调用构造函数

上述伪代码中，执行的顺序可能是(1)(3)(2)，此时不会导致上述问题；但如果(1)(2)(3)的执行过程，则可能在线程1执行到(2)时，CPU开始执行线程2，此时恰好线程2执行到第一次检查，获取到的是一个不为null但尚未初始化的值，此时程序会抛出错误。

使用volatile

在高版本的JDK中，使用volatile关键字可以保证不会产生上述问题。被volatile所修饰的变量的值不会被本地线程缓存，所有对该变量的读写都是直接操作共享内存来实现，从而确保多个线程能正确的处理该变量。
该关键字可能会屏蔽掉虚拟机中的一些代码优化，所以其运行效率可能不是很高。

class Singleton {
    private static volatile Singleton instance;
}

使用内部类

class Singleton {
    private Singleton() {}
    private static class Holder {
        static Singleton instance = new Singleton();
    }
    public static Singleton getInstance() {
        // 外围类能直接访问内部类（不管是否是静态的）的私有变量  
        return Holder.instance;
    }
}

更多资料

1. 单例模式与双重检测
2. 双重检查的缺陷
3. 用happen-before规则重新审视DCL

2.5 多例模式

多例模式实际上就是单例模式的推广，多例类可以有多个实例，多例类必须自己创建、管理自己的实例，并向外界提供自己的实例。

多例模式

多例模式分为有上限多例类和无上限多例类，无上限多例类要通过集合来实现。