【Java EE】-多线程编程(五) 多线程案例之单例模式

作者:学Java的冬瓜
博客主页:☀冬瓜的主页
专栏:【JavaEE】
分享:久闻中原歧王战力无双,今日一见,果非虚言!——《画江湖之不良人》
主要内容:单例模式,饿汉模式和懒汉模式的写法,懒汉模式的深度分析,怎么解决懒汉模式读写非原子,内存可见性以及指令重排序等问题。

【Java EE】-多线程编程(五) 多线程案例之单例模式_第1张图片

文章目录

  • 一、饿汉模式
  • 二、懒汉模式
    • 1、具体分析
    • 2、正确代码和总结

一、饿汉模式

三招:实例私有化、构造方法私有化、只提供getInstance静态方法供外部类使用。

package demo;
// 单例模式
// 饿汉式
class Singleton {
    // 实例私有化
    private static Singleton instance = new Singleton();
    // 构造方法私有化
    private Singleton(){}

    public static Singleton getInstance(){
        return instance;
    }

}
public class Demo1 {
    public static void main(String[] args) {
        // 因为Singleton类构造方法私有,所以不能在Singleton类外new,而只能调用getInstance方法
        // Singleton对象在类加载时就已经创建了,程序员不能再去手动创建,这样就实现了单例,即只有一个实例Singleton对象
        //demo.Singleton s = new demo.Singleton();  // 报错
        Singleton s = Singleton.getInstance();
    }
}

二、懒汉模式

1、具体分析

按照饿汉模式代码的思路,我们写出的懒汉模式的代码如下,但是,下面的代码有问题,什么问题呢?让我们接着往下看

class SingletonLazy {
    private static SingletonLazy instence = null;
    private SingletonLazy(){}

    public static SingletonLazy getInstance(){
        if(instence == null){
            instence = new SingletonLazy();
        }
        return instence;
    }
}

       我们来看看 if(instance == null)这个条件,当多个线程同时进入if,那么这些线程把instance的值拷贝到寄存器上的值都为null,然后寄存器的值和null比较,这个判断就是true,那这些线程都会去创建SingletonLazy对象,那么单例模式就失效了。为什么会创建多个对象呢?其实就是instance的读和写不是原子性导致问题,所以我们就给它加锁,变成如下这样。
【Java EE】-多线程编程(五) 多线程案例之单例模式_第2张图片

       这个改造后的代码还存在问题,你想一下,每次在其它类里使用SingletonLazy s = SingletonLazy.getInstance();获取单例的时候,如果是上面的代码,每次都会加锁,然后再判断。实际上,我们只需要第一次创建实例的时候加锁就行了,因为除去第一次后就只涉及到读,而不涉及到写,所以就不需要加锁以保证效率问题。所以我们就再在加锁外面给一个判断。
【Java EE】-多线程编程(五) 多线程案例之单例模式_第3张图片

       代码写到这里你以为没有问题了?不不不,还有问题!!!
我们假设一个可能存在的场景:此时有很多线程,都去执行getInstance,而此时这些线程都执行到了外层的if这里,然后有一个线程可以获取到锁,然后去内部执行。那么问题来了,这个时候如果内部的if(instance == null)被第一个线程使用时,先把instance的值load到寄存器(或者cache)上,然后比较,然后创建单例。但是当第一个线程释放锁,后续的线程获取到锁进入后,如果不从内存把instance的值加载到寄存器,而是直接从寄存器读那后续线程读到的仍是null,那就又会去创建单例,导致单例失效。这是内存可见性导致单例失效(可以看看之前的博客线程安全里面详细讲了内存可见性问题)。
       接下来还有指令重排序可能导致单例失效。我们先来了解:instance = new SingletonLazy 具体的操作可分为三步:1> 申请内存空间 2> 调用构造方法,把这个内存空间初始化为一个合理的对象 3> 把内存空间的引用给instance对象,如果第一次SingletonLazy s = SingletonLazy.getInstance();创建单例对象时,是1、2、3的顺序执行,那么没有问题。那现在我们又来假设一个可能存在的场景:t1和t2线程,第一次执行getInstance创建单例对象时,t1先执行完1、3,然后被切出CPU(此时t1释放了锁),t2来执行。但是 t2看到t1执行完 3后,就认为instance非空了,就直接返回instance,且t2还可能会使用引用中的属性。但是由于t1还没有执行2操作,所以此时t2拿到这个instance是一个不完整对象,那就可能会出问题。
       那我们从上面的两个分析里知道,上面经过改造的代码还可能存在内存可见性和指令重排序问题,那很明显,就是用volatile解决就行了。改造代码如下:
在这里插入图片描述

2、正确代码和总结

懒汉模式除了三招:实例私有化、构造方法私有化、只提供getInstance静态方法供外部类使用外,还要考虑很多问题:
1> synchronized加锁
2> 双层if判断各自作用
3> volatile解决内存可见性和指令重排序问题

package demo;
// 单例模式
// 懒汉模式
class SingletonLazy {
    // volatile 解决内存可见性和指令重排序问题
    private volatile static SingletonLazy instence = null;
    private SingletonLazy(){}

    public static SingletonLazy getInstance(){
        // 外面的这层if用于判断,如没有这一层判断,则每次进来都会加锁,消耗大量时间做无用功
        if(instence == null){
            // synchronized保证instance的读和写是原子性的
            synchronized (Singleton.class){
                // 判断单例是否已经创建,若无,则创建。
                if(instence == null){
                    instence = new SingletonLazy();
                }
            }
        }
        return instence;
    }
}

你可能感兴趣的:(JAVAEE,单例模式,java-ee,java)