Java单例模式 双重校验锁 为啥要用volatile修饰

最新推荐文章于 2024-12-07 00:01:09 发布
最新推荐文章于 2024-12-07 00:01:09 发布
阅读量1.5k 收藏 3
点赞数 2
CC 4.0 BY-SA版权
分类专栏： Java SSM 文章标签： Java 单例模式 双重校验锁 volatile
原文链接：https://programskills.blog.youkuaiyun.com/article/details/72759403
Java单例模式的双重校验锁（DCL）实现中，volatile修饰变量是为了防止指令重排序导致的线程安全问题。在多线程环境下，不使用volatile可能导致对象在未初始化的情况下被访问。volatile确保了初始化过程的可见性和有序性，保证了单例的正确性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

public class Single {

private static volatile Single single;

public static Single getSingle(){

if (single==null){

synchronized (Single.class){

if (single==null){

single=new Single();

}

}

}

return single;

}

}

因为如果不用volatile修饰的话，在 single=new Single();会发生指令重排序，

Single的代码可以分解为三个部分

  1. 分配对象的内存空间
  2. 初始化对象
  3. 设置single指向内存空间

在JIT里，可能会将2与3进行重排序，在单线程里这里并不会发生什么问题，但是在多线程情况下，会出现下面的问题

时间

线程A

线程B

t1

A1：分配对象的内存空间

 

t2

A3：设置single指向内存空间

 

t3

 

B1:判断single是否为空

t4

 

B2:由于single不为null，线程B将访问single引用的对象

t5

A2：初始化该对象

 

t6

A4：访问single引用的对象

 

A2与A3重排序后，会让线程B在B1处判断出single不为null，线程B接下来将访问的single引用的对象是一个未初始化的对象。

所以用volatile修饰 single来就是禁止2与3的重排序，来保证线程安全的延迟初始化。

转自：https://blog.youkuaiyun.com/OrangeRawNorthland/article/details/83788412

Java volatile作用

Java单例模式 双重校验锁 为何两次if判断？
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
12-28 3430
内层判断：如果内层不加if判断，就会实例化多次，这是显而易见的，这就违背了单例模式的单例二字。 外层判断：试图想想一种情况，当线程1走完了内层判断，对象实例化了，线程3也调用了getInstace函数，如果没有加外层的判断线程3还是要继续等待线程2的完成，而加上外层判断，就不需要等待了，直接返回了实例化的对象。 我的理解：外层的判断是为了提高效率【不必synchronized等待】，里层的判断就是第一次实例化需要。 转自：https://blog.youkuaiyun.com/weixin_38983929/..
Java单例模式 双重校验锁 2021
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
01-29 335
package com.company; /** * @Author you guess * @Date 2021/1/29 09:32 * @Version 1.0 * @Desc 懒汉式 双重校验锁 */ public class SingletonTest { //变量私有 private volatile static SingletonTest instance = null;//用volatile static 修饰 //构造方法私有 priva.
面试官的一道简单的单例模式问题给我问懵了，详解单例模式双重检查加锁为什么要加volatile关键字！
12-21
目录 1.场景： 2.对象的创建过程  3.指令重排 4.CPU执行时间片  5.指令重排对双重检查加锁模式的影响   1.场景： 面试官：有用过单例模式吗？ 我：有有有（自信满满）。 面试官：说说单例模式几种写法？ 我：懒汉式和饿汉式，懒汉式巴拉巴拉，饿汉式巴拉巴拉。 面试官：我们都知道synchronized加锁是比较耗费资源的，你这种写法每次访问都需要获得锁（基础的懒汉式写法），效率比较低，有什么优化的方式吗？ 我：沉思片刻，脑海灵光一现。可以采用双重检查加锁的方式，巴拉巴拉。（还好之前看到过，暗自庆幸） 面试官：为什么双重检查加锁需要加volatile关键字？ 我：要不我们问问度娘？
[转载]双重校验单例模式的经典实现为什么要加volatile
重学Android，保持学习
02-07 177
双重校验单例模式的经典实现为什么要加volatile 这里加volatile关键字的用途是为了防止指令重排 class Singleton{ private volatile static Singleton singleton; public static Singleton getInstance(){ if(singleton == null){ // 语句1 synchronize
面试官竟然不知道Java单例模式双重检验锁一定要加volatile！
JavaEdge全是干货的技术号
04-04 2782
对于 T t = new T(); 其实有如下字节码指令完成 _new 'org/openjdk/jol/T' dup INVOKESPECIAL org/openjdk/jol/T.<init> ()V astore 1 return 线程一 new 到一半时,m=0,发生重排序 这时线程 2 来了!看到 t 已经指向了一个半初始化的实例了! 这个概率很小,但是并发如淘宝,...
java并发编程—单例模式双重校验锁变量为什么使用 volatile 修饰？
l_010的博客
06-09 770
java并发编程—单例模式双重校验锁变量为什么使用 volatile 修饰？
单例模式——Double Check 双重校验锁实现方式为什么要加volatile关键字
newbiee的博客
07-30 681
单例模式——Double Check 双重校验锁实现方式为什么要加volatile关键字 单例模式双重校验锁实例： public class Singleton { private static volatile Singleton singleton = null; private Singleton() {} public static Singleton getInstance(){ //第一次校验singleton是否为空 if(
java单例模式懒汉式 双重校验 关键字volatile
zhzjn的博客
10-11 1079
Volatile关键字的作用主要有如下两个：1.线程的可见性：当一个线程修改一个共享变量时，另外一个线程能读到这个修改的值。2.顺序一致性：禁止指令重排序。不保证原子性。
java并发编程(二十六)——单例模式的双重检查锁模式为什么必须加 volatile？
程序员资料站
01-03 856
我们为什么需要单例呢？其中**一个理由，那就是为了节省内存、节省计算。**因为在很多情况下，我们只需要一个实例就够了，如果出现更多的实例，反而纯属浪费。
双重检查锁 已经用锁 为何还要使用volatile 详解
T_Y_F_的博客
12-07 1086
双重检查锁 已经用锁 为何还要使用volatile 详解
双重检查锁要不要加volatile
weixin_49181615的博客
09-15 1785
首先给出结论：双重检查锁是需要加volatile的。 先介绍下双重检查锁：
关于Java单例模式中双重校验锁的实现目的及原理
dongchen7648的博客
09-02 373
开始复习设计模式，一开始理解单例模式中的双重校验锁卡住了，想通了后就自己做了段思维导图来帮助自己理解。 其实理解下来并不难，但还是记录下来帮助自己回忆和借机试试养成写博客的习惯~ public class Singleton { private volatile static Singleton uniqueInstance; private Sing...
单例模式中volatile关键字的作用
大叶子不小的博客
07-22 1052
什么是单例模式 单例模式指的是，保证一个类只有一个实例，并且提供一个可以全局访问的入口。 为什么需要使用单例模式 那么我们为什么需要单例呢？其中一个理由，那就是为了节省内存、节省计算。因为在很多情况下，我们只需要一个实例就够了，如果出现更多的实例，反而纯属浪费。 下面我们举一个例子来说明这个情况，以一个初始化比较耗时的类来说，代码如下所示： public class ExpensiveResource { public ExpensiveResource() { field1 = /
面试突击51：为什么单例一定要加 volatile？
磊哥聊Java
06-06 3475
.作者 | 磊哥来源 | Java面试真题解析（ID：aimianshi666）转载请联系授权（微信ID：GG_Stone）单例模式的实现方法有很多种，如饿汉模式、懒汉模式、静态内部类和枚举等，当面试官问到“为什么单例模式一定要加 volatile？”时，那么他指的是为什么懒汉模式中的私有变量要加 volatile？懒汉模式指的是对象的创建是懒加载的方式，并不是在程序启...
通过单例模式中的双重校验锁来解读volatile
gaston的博客
08-08 1308
Java并发编程：volatile关键字解析 在学习设计模式的时候看到了单例模式中的双重锁,于是就结合资料进行了总结。 volatile这个关键字可能很多朋友都听说过，或许也都用过。在Java 5之前，它是一个备受争议的关键字，因为在程序中使用它往往会导致出人意料的结果。在Java 5之后，volatile关键字才得以重获生机。 　　volatile关键字虽然从字面上理解起来比较...
双重检查锁单例模式为什么要用volatile关键字？
程序员追风的博客
08-15 4079
前言 从Java内存模型出发，结合并发编程中的原子性、可见性、有序性三个角度分析volatile所起的作用，并从汇编角度大致说了volatile的原理，说明了该关键字的应用场景；在这补充一点，分析下volatile是怎么在单例模式中避免双检锁出现的问题的。 并发编程的3个条 件 1、原子性：要实现原子性方式较多，可用synchronized、lock加锁，AtomicInteger等，但volat...
Java | 单例模式中双重校验锁的volatile变量有什么作用？
俗人
03-26 468
单例模式的双重校验锁方式如下： /** * 双重校验锁(在饿汉模式基础上进一步优化) * 1、构造方法私有化 * 2、在定义静态对象时加volatile锁来确保初始化时对象的唯一性 * 3、定义获取对象实例方法，并在方法体中通过synchronized(Object)给单例类加锁来保障操作的唯一性 * */ class DoubleCheckedLockingSingleton{ ...
JAVA：【基础六】单例模式为什么使用volatile，以及双重检查
叫我吕小布
02-16 1982
创建单例的双重检测机制，及volatile关键字的使用
为什么双重校验锁单例需要 `volatile` 关键字?
最新发布
06-25
<think>我们正在讨论双重校验锁单例模式中volatile关键字的作用。根据提供的引用，特别是引用[1]、[2]、[3]、[4]、[5]，我们可以总结出以下关键点：1.**双重检查锁定（DCL）的目的**：在保证线程安全的同时，减少同步带来的性能开销。通过两次检查（一次在同步块外，一次在同步块内）来确保只有在实例未初始化时才进行同步创建。2.**为什么需要volatile**：主要原因是防止指令重排序（instructionreordering）导致的线程安全问题。在Java中，创建一个对象（`instance=newSingleton();`）并不是一个原子操作，它分为三个步骤：-分配内存空间-初始化对象（调用构造函数）-将实例引用指向分配的内存地址但是，由于指令重排序的优化，步骤2和步骤3可能会被重新排序。也就是说，可能出现先分配内存空间，然后将引用指向该内存，最后才初始化对象的情况。3.**重排序带来的问题**：假设有两个线程A和B：-线程A进入同步块，执行`instance=newSingleton();`，此时由于重排序，对象还未初始化完成，但引用已经不为null（即已经指向了分配的内存地址）。-此时线程B调用`getInstance()`，在第一次检查`instance==null`时发现不为null，于是直接返回`instance`，但此时`instance`指向的对象还未初始化完成（构造函数未执行完），导致线程B使用了一个不完整的对象。4.**volatile的作用**：-禁止指令重排序：使用volatile修饰的变量，会插入内存屏障（MemoryBarrier），确保写操作之前的指令不会被重排序到写操作之后，读操作之后的指令不会被重排序到读操作之前。-保证可见性：当一个线程修改了volatile变量的值，其他线程能立即看到修改后的值。在单例模式中，volatile修饰的`instance`变量，可以确保在对象初始化完成之后，才将引用赋值给`instance`，从而避免其他线程看到未初始化的对象。5.**引用中的说明**：-引用[1]和[2]指出volatile主要是为了保证线程安全，避免指令重排序问题。-引用[3]和[4]强调volatile防止了JVM的指令重排序，确保单例对象只会被创建一次。-引用[5]详细解析了指令重排序导致的问题以及volatile如何解决。因此，在双重校验锁单例模式中，`volatile`关键字是必需的，它解决了由于指令重排序导致的线程安全问题。###总结：-**没有volatile**：可能发生指令重排序，导致其他线程获取到未完全初始化的实例。-**使用volatile**：禁止与实例创建相关的指令重排序，保证对象初始化完成后再赋值给引用，从而确保线程安全。###相关问题：1.除了双重检查锁，还有哪些线程安全的单例实现方式？2.volatile关键字在Java内存模型（JMM）中还有哪些作用？3.为什么双重检查锁中需要两次判空？4.指令重排序在哪些情况下会发生？</think>### 双重校验锁单例模式中 `volatile` 关键字的作用解析 在双重检查锁定（Double-Checked Locking, DCL）实现单例模式时，`volatile` 关键字的核心作用是**防止指令重排序**，确保多线程环境下对象初始化的原子性和可见性。以下是详细解析： #### 1. **对象创建的非原子性问题** 对象实例化 `instance = new Singleton()` 包含三个关键步骤： 1. 分配对象内存空间 2. 初始化对象（调用构造函数） 3. 将引用指向内存地址 ```java instance = new Singleton(); // 非原子操作 ``` 在没有 `volatile` 的情况下，JVM 可能对指令进行重排序，将步骤3提前到步骤2之前执行（即先分配地址再初始化）。这种重排序在单线程中无影响，但在多线程中会导致严重问题。 #### 2. **多线程下的失效场景** 假设线程A执行创建操作时发生指令重排序： 1. 分配内存空间 2. **将引用指向内存地址（此时 instance ≠ null）** 3. 初始化对象（构造函数未完成） 此时线程B调用 `getInstance()`： ```java if (instance == null) { // 判断为 false（因为引用已存在） return instance; // 返回未初始化的半成品对象！ } ``` **结果**：线程B获得了一个未完成初始化的对象，可能导致空指针异常或状态错误。 #### 3. **`volatile` 的解决方案** 通过 `volatile` 修饰实例变量： ```java private static volatile Singleton instance; ``` 该关键字实现两个关键保障： 1. **禁止指令重排序** 在写操作前后插入内存屏障（Memory Barrier），确保： - 对象完全初始化完成 - **之后**才将引用赋值给 `instance` 2. **保证可见性** 确保一个线程修改 `instance` 后，其他线程能立即看到最新值（通过主内存同步） #### 4. **内存屏障原理** `volatile` 在字节码层面生成以下屏障： ``` StoreStore Barrier // 阻止初始化操作之前的写重排序 初始化对象 StoreLoad Barrier // 阻止初始化与引用赋值的重排序 赋值 instance LoadLoad Barrier // 确保后续读操作能看到完整对象 ``` #### 5. **与普通锁定的对比** | 方案 | 性能 | 线程安全 | 初始化时机 | |--------------------|------------|----------|------------------| | 同步方法锁 | 差（每次调用加锁） | 安全 | 首次调用 | | 双重检查锁无volatile | 好 | **不安全** | 首次调用 | | 双重检查锁+volatile | 好 | 安全 | 首次调用 | > 引用[5]明确指出：*"volatile 可以防止某些 JVM 在多线程环境中可能出现的指令重排序问题，确保单例对象只会被创建一次"*[^5]。 ### 总结 `volatile` 在 DCL 单例模式中是**必需的**，它解决了以下问题： 1. **防止指令重排序** → 避免返回未初始化的对象 2. **保证内存可见性** → 确保所有线程看到一致状态 3. **维持性能优势** → 仅在首次初始化时同步 > 引用[3]强调：*"虽然之前了解了双重检查锁定模式的原理，但是却忽略变量使用了 volatile"*[^3]，这恰恰是线程安全的关键所在。 ```mermaid sequenceDiagram participant ThreadA as 线程A(创建者) participant Memory as 主内存 participant ThreadB as 线程B(使用者) ThreadA->>Memory: 1.分配内存 ThreadA->>Memory: 2.初始化对象(构造函数) ThreadA->>Memory: 3.volatile写屏障(禁止重排序) ThreadA->>Memory: 4.赋值instance Memory-->>ThreadB: 5.volatile读屏障(强制同步) ThreadB->>Memory: 6.安全获取完整对象 ```
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值