一起学设计模式-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的引用,在使用过程中就会发异常。

CPU时间线程A线程B
1给singleton分配内存getInstance()
2返回对象singleton在堆的引用 进行singleton == null判断 返回false
3.实例初始化return 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对象
0

说点什么

avatar
  Subscribe  
提醒