【并发专题】单例模式的线程安全(进阶理解篇)

目录

背景

最近学习了JVM之后,总感觉知识掌握不够深,所以想通过分析经典的【懒汉式单例】来加深一下理解。(主要是【静态内部类】实现单例的方式)。

如果小白想理解单例的话,也能看我这篇文章。我也通过了【前置知识】跟【普通懒汉式】、【双检锁懒汉】、【静态内部类】懒汉给大家分析了一下他们的线程安全性。但是,我这边没有完整的演进【懒汉式单例】历程。所以,会缺少思维上的递进。不过,我在最后的【感谢】名单里,提供了一个完整的【懒汉式单例演进】的链接,建议可以结合这个文章一起学习。

前置知识

类加载运行全过程

当我们用java命令运行某个类的main函数启动程序时,首先需要通过类加载器把主类加载到JVM。

java 复制代码
package com.tuling.jvm;

public class Math {
    public static final int initData = 666;
    public static User user = new User();

    public int compute() {  //一个方法对应一块栈帧内存区域
        int a = 1;
        int b = 2;
        int c = (a + b) * 10;
        return c;
    }

    public static void main(String[] args) {
        Math math = new Math();
        math.compute();
    }
}

通过Java命令执行代码的大体流程如下:

其中loadClass的类加载过程有如下几步:
加载 >> 验证 >> 准备 >> 解析 >> 初始化 >> 使用 >> 卸载

  • 加载:在硬盘上查找并通过IO读入字节码文件,使用到类时才会加载,例如调用类的main()方法,new对象等等,在加载阶段会在内存中生成一个代表这个类的java.lang.Class对象,作为方法区这个类的各种数据的访问入口
  • 验证:校验字节码文件的正确性
  • 准备:给类的静态变量分配内存,并赋予默认值
  • 解析:将符号引用替换为直接引用,该阶段会把一些静态方法(符号引用,比如main()方法)替换为指向数据所存内存的指针或句柄等(直接引用),这是所谓的静态链接过程(类加载期间完成),动态链接是在程序运行期间完成的将符号引用替换为直接引用,下节课会讲到动态链接
  • 初始化:对类的静态变量初始化为指定的值,执行静态代码块

总结一下,上面说的加载 >> 验证 >> 准备 >> 解析 >> 初始化过程是由JVM帮我们进行的,所以,对我们程序员来说,【天生】就具备线程安全性(这个由JVM帮我们保证,无需我们关心)。

单例模式的实现方式

单例模式,是我们Java中很常见的一个设计模式。所以有这么一种说法:遇事不决,单例解决。

Java单例通常有2种,分别为:饿汉式、懒汉式

一、饿汉式

基本介绍

饿汉式(Eager Initialization,急切的初始化),在类加载时就创建单例实例,并在需要时直接返回该实例。这种方式的实现是线程安全的,因为在类加载过程中实例已经创建好了。

源码

java 复制代码
public class SingletonTest {
    private static final SingletonTest me = new SingletonTest();
    
    public static SingletonTest me() {
        return me;
    }
    
    public static void main(String[] args) {
        System.out.println(SingletonTest.me());
        System.out.println(SingletonTest.me());
        System.out.println(SingletonTest.me());
    }
//    系统输出如下:
//    org.tuling.juc.singleton.SingletonTest@12a3a380
//    org.tuling.juc.singleton.SingletonTest@12a3a380
//    org.tuling.juc.singleton.SingletonTest@12a3a380
}

分析

因为单例对象SingletonTest 是静态成员变量,所以,在JVM类加载过程中==(加载-》验证-》准备-》解析-》初始化)==的【解析】阶段已经被JVM初始化了,所以,由JVM保证了线程安全性。

二、懒汉式

基本介绍

懒汉式(Lazy Initialization),在首次调用时创建单例实例,存在线程安全问题。如果多个线程同时进入判断条件,可能会创建多个实例。

源码

java 复制代码
public class SingletonTest {
    private static SingletonTest me;

    public static SingletonTest me() {
        if(me == null) {
            me = new SingletonTest();
        }
        return me;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                System.out.println(SingletonTest.me());
            }).start();
        }
    }
}

输出结果如下

分析

为什么上面这段代码不是线程安全的呢?我们举一个极端的例子,如下图所示:

在没有锁机制的存在情况下,多线程环境里面可能会出现上述的并发执行情况。在线程1判断完me == null之后,即将开始执行new之前,线程2也刚好在判断me == null,这是因为线程1还没有执行new操作,所以线程2判断肯定是null的,于是也开始new。这就是线程安全问题所在。
(PS:小白们一定要理解上面这个图。虽然很简单,但是说它是你们迈向,或者培养【并发意识】的启蒙都不为过。)

改进

为了解决上面的问题,大牛们进行了改进,使用了【双检锁+volatile】机制,【双检锁】,即:双重检查锁。代码如下:

java 复制代码
public class SingletonTest {
    private static volatile SingletonTest me;

    public static SingletonTest me() {
        if(me == null) {
            synchronized (SingletonTest.class) {
                if (me == null) {
                    me = new SingletonTest();
                }
            }
        }
        return me;
    }
}

上面的改进,关键点如下:

  1. 使用了volatile关键字修饰单例对象me
  2. 在获取单例对象的时候,判断了两次if(me == null)
  3. 第二次判断if(me == null)之前,先加了锁

第二、三点我就不说了,大家可以看看最下面【感谢】的友链。这里重点说说第一点。

估计小白会很难理解,为什么一定要volatile关键字修饰,不用可以吗?答案是:不可以。因为,volatile能禁止重排序。什么是【重排序呢】?说的简单点,就是JVM,甚至是CPU为了性能,可能会在不改变语义的情况下修改我们的代码执行顺序。比如,当我们new SingletonTest()的时候,你以为只有一步操作,实际上,它有3步,如下:

memory = allocate(); // 1.分配对象内存空间

instance(memory); // 2.初始化对象

instance = memory; // 3.设置instance指向刚分配的内存地址,此时instance!=null

但事实上,经过重排序之后可能会变成下面的执行顺序:

memory = allocate(); // 1.分配对象内存空间

instance = memory; // 3.设置instance指向刚分配的内存地址,此时instance!=null

instance(memory); // 2.初始化对象

然后大家再用上面的【并发启蒙】意识,自己画个图看下,还能线程安全吗?

所以,需要使用volatile关键字,告诉底层JVM或者CPU,不要帮我重排序这个对象!于是就避免了上面的并发线程安全问题了。

三、懒汉式单例终极解决方案(静态内部类)(推荐使用方案)

基本介绍

这里通过利用JVM类加载【天生线程安全】的特性,来帮助实现【懒汉式】的单例。如何做到呢?答案是【静态内部类】。

源码

java 复制代码
public class SingletonTest {
    /** 单例对象,可以直接调用配置属性  */
    private static class Holder {
        private static SingletonTest me = new SingletonTest();
    }
    public static SingletonTest me() {
        return Holder.me;
    }

    public static void main(String[] args) {
        int threadCount = 10000;
        for (int i = 0; i < threadCount; i++) {
            new Thread(()->{
                System.out.println(SingletonTest.me());
            }).start();
        }
    }
}

上面的代码,新建了1W个线程来调用单例,我们发现,结果都是一样,同一个对象。

分析

为什么上面,通过静态内部类能保证线程安全性呢?这个我们在【前置知识】已经说过了,是由JVM保证了线程安全性。

如上图所示,只有当我们使用了SingletonTest.me()的时候,才会去开始加载Holder静态内部类,这就是它实现【懒汉式】的原因(延迟加载)。

感谢

感谢【作者:weixin_47196090】的深度好文,《懒汉式单例演进到DCL懒汉式 深度全面解析

相关推荐
cdprinter4 分钟前
信刻——安全生产音视频录音录像自动刻录备份归档管理系统
安全·自动化·音视频
四谎真好看26 分钟前
Java 黑马程序员学习笔记(进阶篇18)
java·笔记·学习·学习笔记
桦说编程32 分钟前
深入解析CompletableFuture源码实现(2)———双源输入
java·后端·源码
java_t_t32 分钟前
ZIP工具类
java·zip
lang201509281 小时前
Spring Boot优雅关闭全解析
java·spring boot·后端
pengzhuofan2 小时前
第10章 Maven
java·maven
百锦再2 小时前
Vue Scoped样式混淆问题详解与解决方案
java·前端·javascript·数据库·vue.js·学习·.net
刘一说2 小时前
Spring Boot 启动慢?启动过程深度解析与优化策略
java·spring boot·后端
壹佰大多3 小时前
【spring如何扫描一个路径下被注解修饰的类】
java·后端·spring
嘉里蓝海3 小时前
橙色风暴中的安全守卫者——嘉顺达蓝海的危险品运输启示录
安全