一起学设计模式-01 单例模式

 

单例模式，说穿了就是整个程序的生命周期内，不管怎么调用，只会创建一个实例。都有哪些场景用了单例呢：

 

• 数据库连接池是单例的（注意是管理连接的池，不是连接）
• Spirng的Bean是单例的
• 网站的计数器是单例的

 

单例模式有多种写法，这里挑选比较有代表性的“懒汉式”和“饿汉式”和“双重检查式”来讲。笔者一开始接触的时候，只知道死记写法，这样的后果就是忘得非常快。所以一定还是要理解，融会贯通了才能实现记忆持久化。实际上，这三种写法，其写法总结起来就是三部分构成：

 

• 1.私有的静态成员变量 （最小化可见性）
• 2.私有的构造方法 （杜绝类外构造的可能）
• 3.获取类实例的唯一静态方法getInstance（唯一入口）

 

 

 

饿汉式写法：

 

饿汉式，由于其实例的创建是写在静态代码内，在类首次加载的时候就会被创建(不明白的要看下类初始化顺序)，因此饿汉式有天然的线程安全，调用效率高（实例一早就被创建好了，不存在并发创建出多个实例的情况）。同时由于只要加载类就创建实例，就像个饿鬼一样，不管吃不吃一定要有吃的，因此饿汉式的缺点在于非延迟加载，可能造成空间浪费。如果不在意空间，这个当然是最简便的实现单例的方式。

 

public class HungrySingleton{
    //私有的静态成员变量，一上来就实例化
    private static HungrySingleton hungrySingleton = new HungrySingleton();
    //私有的构造方法
    private HungrySingleton(){}

    //获取实例的唯一入口
    public static HungrySingleton getInstance(){
        return hungrySingleton;
    }

}

 

懒汉式一般线程安全写法：(不推荐)

 

懒汉式支持延迟加载，也就是说实例的创建会一直拖着，直到实例需要被使用的时候才做第一次创建。懒汉式并不具备天然线程安全特性，因此需要使用sysnchronized关键字来保证同步。一般线程安全写法调用效率相对较低，实际应用上几乎不会使用。

 

public class LazySingleton{
    //私有的静态成员变量
    private static LazySingleton lazySingleton;
    //私有的构造方法
    private LazySingleton(){}

    //获取实例的唯一入口, 方法上加了synchronized关键字来保证同步
    public static synchronized LazySingleton getInstance(){
        if(lazySingleton == null){
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }

}

 

懒汉式双重检查写法（推荐）

 

双重检查式，可以看做改良的懒汉式写法，是比较推荐的写法。和普通懒汉式写法相比，其写法差异在于：

 

• 使用了volatile关键字对私有单例类变量进行了修饰，禁止重排序
• synchronized 加锁在代码段而不是整个方法
• 且多出了null值一次检查。

 

public class DoubleCheckSingleton{
    //私有的静态成员变量,使用volatile禁止重排序
    private volatile static DoubleCheckSingleton doubleCheckSingleton;
    //私有的构造方法
    private DoubleCheckSingleton(){}

    //获取实例的唯一入口
    public static  DoubleCheckSingleton getInstance(){

        if(doubleCheckSingleton == null){
            //同步加锁的位置在方法内，且在第一重判断内
            //这样只有在第一次创建对象时需要加锁，其他时间都会在第一重判断处就返回，不会进入同步代码块
            synchronized (DoubleCheckSingleton.class){
                //在同步代码块内进行第二重判断
                if (doubleCheckSingleton == null){
                    doubleCheckSingleton = new DoubleCheckSingleton();
                }
            }
        }

        return doubleCheckSingleton;
    }

}

 

 

这样在保证线程安全的前提下，降低了synchronized关键字造成的性能下降问题，因为加锁只会发生在实例第一次创建的时候，其他时候都不会进入同步的代码块，是单例模式的推荐写法。

 

关于双重检查式写法，大家通常会有两个问题：

 

为啥使用volatile关键字和为啥进行两次检查。我们一个一个说。

 

1.为啥使用volatile关键字：

 

一个对象的创建，会经过下面的步骤：

 

1. 内存分配
2. 对象初始化
3. 返回对象在堆的引用

 

而JVM有时候为了提高效率，会对指令进行重排，打乱这个顺序变成 内存分配 >> 返回对象在堆的引用 >> 对象初始化。如果不加volatile关键字禁止重排，可能会出现其他线程获取到了一个未初始化完成的实例的引用，导致程序出错。

 

我们看下下面这种情况，由于重排，对象的创建顺序被调整，变为132。此时线程A刚好返回singleton的引用，但是singleton并未完成初始化。此时线程B刚好执行了singleton==null的判断，返回false，于是线程B就得到未完成初始化的singleton的引用，在使用过程中就会发异常。

 

2.为啥需要两次检查：

 

第一层null检查前面说过了，是为了减少进入synchronized的次数，确保只在实例第一次初始化时需要进入同步代码块，提升程序性能。

 

现在我们把getInstance方法的第二层检查去掉，代码变成下面这样

    public static  DoubleCheckSingleton getInstance(){
        if(doubleCheckSingleton == null){
            synchronized (DoubleCheckSingleton.class){
                //去掉了第二重判断
                doubleCheckSingleton = new DoubleCheckSingleton();
            }
        }
        return doubleCheckSingleton;
    }

 

 

假设有两个线程同时通过了第一重校验，执行到了synchronized (DoubleCheckSingleton.class)这一行。此时，线程A获得了锁，线程B由于没有获得锁，因此必须等待A执行完同步代码块后再进入同步代码块。A执行完同步代码块，创建了一个singleton实例，并释放锁。此时B获得锁，由于没有第二重校验，B也会创建一个singleton实例，这就不再是单例了。

 

CPU时间	线程A	线程B
1	获得锁，进入同步块	等待锁
2	创建singleton对象	获得锁，进入同步块
3.	释放锁	创建singleton对象