面试题：双重检验锁⽅式实现 单例模式

最新推荐文章于 2025-05-14 11:12:11 发布
原创 最新推荐文章于 2025-05-14 11:12:11 发布 · 425 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#面试 #volatile #指令重排 #双重检验锁 #单例模式

本文介绍了如何使用双重检验锁（Double-Check Locking）方式来实现Java中的单例模式，并重点讨论了volatile关键字在此处的作用，即避免构造方法的指令重排导致的线程安全问题。在多线程环境下，volatile确保了在类对象初始化完成之前，不会有其他线程能够看到部分初始化的实例，保证了单例的正确性。

面试题：双重检验锁方式实现 单例模式

关键词

  • volatile 禁⽌ JVM 中 构造方法的 指令重排

编码实现

public class Singleton {
   
   
	private volatile static Singleton instance;
	
	private Singleton() {
   
   
	}
	
	public static
最低0.47元/天 解锁文章
Android经典面试题之Kotlin中object关键字实现的是什么类型的单例模式？原理是什么？怎么实现双重检验锁单例模式？
AntDream的程序世界
07-18 1011
直接使用object关键字创建单例对象，这是最简单的方法。这个方法不需要编写额外的代码来确保该对象只有一个实例。Kotlin 提供了多种方便且简洁的方法来实现单例模式：1、Object 关键字：最简单的方式，适用于没有参数的单例。2、伴生对象以及自定义静态方法：适用于需要初始化参数或自定义初始化逻辑的单例。也就是Java中的DCL单例根据实际需求选择合适的方法，可以让你的代码更加简洁和有效。欢迎关注我的公众号AntDream查看更多精彩文章！
大厂面试真题：阿里经典双重检测DCL对象半初始化问题
个人专长：数据结构和算法、大数据、数据库、主流框架
10-07 879
双重检测锁是一种用于实现单例模式的线程安全方法。在多线程环境下，它允许延迟对象的初始化，同时减少同步的开销。其基本思路是：在第一次检查对象是否已经被实例化时，不需要加锁，只有在对象尚未被实例化的情况下，才进入同步块进行加锁和实例化操作。
双重校验锁实现单例模式
热门推荐
yuan_qh的博客
08-21 2万+
package cn.yqh.interview; /** * @author 袁 * @create 2019/8/21-11:48 */ public class Singleton { private static volatile Singleton singleton = null; priva...
双重校验实现单例模式
Xue_99的博客
08-09 478
public class Singleton{ private volatile static Singleton uniqueInstance; public static Singleton getUniqueInstance(){ //先判断对象是否已经实例化过，没有实例化才进入加锁代码 if(uniqueInstance==null){ //类对象加锁 synchronized(Singleton.class){ if(uniqueInstance==null){
双重校验锁方式实现单例模式
小望没烦恼的博客
04-19 389
/** *双重校验锁方式实现单例模式 */ public class Singleton { //静态实例变量 private volatile static Singleton uniqueInstance; // 私有化构造函数 private Singleton() { } // 静态public方法，向整个应用提供单例获取方式 public static Singleton getUniqueInstance() { //第一重
双重检验锁方式实现单例模式
qq_63837759的博客
05-06 1718
正常步骤是1->2->3，但是JVM具有指令重排序的特性，在单线程下是不会存在问题的，但是在多线程下，会导致一个线程拿到还没有进行初始化的实例，例如线程1执行了1->3，然后线程二获取这个实例，发现不为空，拿到但是结果是没有初始化的。根据输出以及当前创建的对象，我们可以看到他创建了不同的对象，所以，为了解决这个方法，我们在创建对象的时候使用。其实这种实现方式也不是完美的，因为Java中那可是存在反射的，他就可以破坏对象的单例！你写的代码------------------>JIT优化之后的代码。
双重校验锁机制实现单例模式
zhouhe999的博客
12-30 1345
解决单例模式的漏洞，仅仅依靠在上次代码实现单例模式是不可行的，依靠上次的设计模式下，其保持可靠性的必要条件是该代码需在单线程的情况下进行执行，若是存在多线程就难以保证对象的唯一性，线程A，线程B，先后执行get方法，进行对象为空的判断，某个线程争抢到锁资源，进行实例化对象，并进行赋值，细节处理，在创建对象是需要在进行一次对象为空的判断，因为该线程执行完实例化对象后，其他线程抢到锁资源，会再次创建一...
静态内部类实现单例_单例模式详解
weixin_39713814的博客
12-08 4688
概述单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，使用单例模式的类只有一个对象实例。单例应用场景Windows系统的任务管理器。Windows系统的回收站。操作系统的文件系统，一个操作系统只能有一个文件系统。数据库连接池的设计与实现。多线程的线程池设计与实现。Spring中创建的Bean实例默认都是单例。Java-Web中，一个Ser...
设计模式学习笔记（四）单例模式的实现方式和使用场景
weixin_45566993的博客
03-26 1559
Python微信订餐小程序课程视频 https://edu.youkuaiyun.com/course/detail/36074 Python实战量化交易理财系统 https://edu.youkuaiyun.com/course/detail/35475 单例模式可以说是Java中最简单的设计模式，也是技术面试中频率极高的面试题。因为它不仅涉及到设计模式，还包括了关于线程安全、内存模型、类加载等机制。所以下面就来分别从单例模式的实现方法和应用场景来介绍一下单例模式 一、单例模式介绍 1.1 单例模式是什么 单例模式也就是指在整个
双重检查加锁单例模式
Mosquito_2的博客
02-23 499
双重检查加锁单例模式 先列一段代码 package cn.xpu.lw.test; public class Singleton { private static volatile Singleton singleton = null; private Singleton() { } public static Singleton getInstance(){ //第一次校验singleton是否为空 if(singleton==nul
Java双重校验锁实现单例模式
王飞的博客
08-28 529
为什么要用双重校验锁实现单例模式？ 单例实现有饿汉模式与懒汉模式，懒汉模式能够延迟加载，使用较多，但是懒汉模式在多线程下会出现问题，即有可能会产生多个实例。 下面是懒汉模式实现的单例模式的代码 public class SingleTon{ //静态实例变量 private static SingleTone instance; //无参构造函数 private SingleTon(){} //获取单例的公共方法 public static synchronized SingleTon getI
双重校验锁实现单例模式（对象单例，线程安全）-- 转载
有一颗前端心的后端开发小哥
02-23 283
双重校验锁实现单例模式（对象单例，线程安全） public class Singleton { //采用volatile修饰 private volatile static Singleton singleton; //构造方法私有化 private Singleton(){} //双重校验锁 public static Singleton getInstance(){ //先判断对象是否已经实例过，没有实例化过才进入加锁代码
DCL（Double-checked Locking双重校验锁）实现单例模式的原理、问题与解决方案
weixin_42526310的博客
05-14 130
单例即单实例，只实例出来一个对象。一般在创建一些管理器类工具类的时候，需要用到单例模式，比如JDBCUtil类，我们只需要一个实例即可（多个实例也可以实现功能，但是增加了代码量且降低了性能）。之所以这样设计，是因为类的静态内部类在JVM中是唯一的，这就很好地保障了单例对象的唯一性。静态内部类的单例实现方式同样是线程安全的。饿汉模式和静态内部类实现单例模式的优点是写法简单，缺点是不适合复杂对象的创建。对于涉及复杂对象创建的单例模式，比较优雅的实现方式是懒汉模式，
单例模式之「双重校验锁」
IT枫斗者的博客
10-17 1134
/ 加 volatileif (INSTANCE == null) { // 双重校验：第一次校验synchronized(Lock2Singleton.class) { // 加 synchronizedif (INSTANCE == null) { // 双重校验：第二次校验过程如下：判断 INSTANCE 是否为null，检查变量是否被初始化（不去获得锁），如果已被初始化立即返回这个变量；不为null，直接返回，不用去竞争锁。
单例双重校验
赵智任的博客
03-30 1171
/** * 描述: * 双重校验 * * @author 小纸人 * @create 2019-03-10 22:40 */ public class DoubleCheckSingleton { private static DoubleCheckSingleton instance; private DoubleCheckSingleton(){ } ...
双重检验锁⽅式实现单例模式的原理-来源JavaGuide
weixin_43888912的博客
02-28 286
学习目标： 提示：多线程实例 整理学习内容-Guide哥的内容 学习内容： 双重检验锁⽅式实现单例模式的原理 实例目的：保证线程安全 学习代码： public class Singleton { private volatile static Singleton uniqueInstance; private Singleton() { } public static Singleton getUniqueInstance() { //先判断对象是否已经实例过，没有实例化过才进⼊加锁代码 if
双重检验锁实现单例模式
weixin_45682305的博客
07-31 285
指令重排在单线程环境下不会出现问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。双重检验锁实现单例模式——在很多地方看到这个代码，涉及的知识点很多，包括单例模式、synchronized锁、指令重排等。给当前类加锁，会作用于类的所有对象实例 ，进入同步代码前要获得。方法，而线程 B 需要调用这个实例对象所属类的静态。方法，是允许的，不会发生互斥现象，因为访问静态。给当前对象实例加锁，进入同步代码前要获得。方法占用的锁是当前类的锁，而访问非静态。方法占用的锁是当前实例对象锁。
双重检验锁⽅式实现单例模式（线程安全）
m0_71837135的博客
05-05 265
但是由于 JVM 具有指令重排的特性，执⾏顺序有可能变成 1->3->2。例如，线程 T1 执⾏了 1 和 3，此时 T2 调⽤ getUniqueInstance () 后发现 uniqueInstance 不为空，因此返回 uniqueInstance ， 但此时 uniqueInstance 还未被初始化。uniqueInstance 采⽤ volatile 关键字修饰也是很有必要的， uniqueInstance = new Singleton();
什么是单例模式面试题
最新发布
06-06
<think>我们正在讨论单例模式，这是一个常见的设计模式，用于确保一个类只有一个实例，并提供全局访问点。根据引用内容，单例模式在面试中经常被考察，通常要求实现两种类型并解释原理[^1]。我将按照以下结构回答：1.单例模式的定义2.单例模式的实现方式（多种方法，每种方法代码示例和优缺点）3.面试中的常见问题（包括线程安全、反射破坏、序列化破坏等）4.相关问题（根据用户要求生成）##1.单例模式的定义单例模式（SingletonPattern）是一种创建型设计模式，确保一个类只有一个实例，并提供全局访问点。这通常用于需要控制资源访问的场景，如数据库连接池、线程池或配置管理等[^1]。##2.单例模式的实现方式###(1)饿汉式（EagerInitialization）在类加载时就创建实例，线程安全（由JVM类加载机制保证）。```javapublicclassSingleton{privatestaticfinalSingletonINSTANCE=newSingleton();privateSingleton(){}//私有构造器防止外部实例化publicstaticSingletongetInstance(){returnINSTANCE;}}```**优点**：实现简单，线程安全。**缺点**：如果实例未被使用，会造成资源浪费（因为它是在类加载时就初始化）[^4]。###(2)懒汉式（LazyInitialization，线程不安全版）延迟初始化，但多线程环境下不安全。```javapublicclassSingleton{privatestaticSingletoninstance;privateSingleton(){}publicstaticSingletongetInstance(){if(instance==null){instance=newSingleton();//多线程下可能创建多个实例}returninstance;}}```**缺点**：线程不安全。###(3)同步懒汉式（SynchronizedMethod）在`getInstance()`方法上加同步锁保证线程安全。```javapublicclassSingleton{privatestaticSingletoninstance;privateSingleton(){}publicstaticsynchronizedSingletongetInstance(){if(instance==null){instance=newSingleton();}returninstance;}}```**优点**：线程安全。**缺点**：每次调用`getInstance()`都要加锁，性能差。###(4)双重检查锁（Double-CheckedLocking）使用双重检查减少锁竞争，并利用`volatile`保证可见性和禁止指令重排序。```javapublicclassSingleton{privatestaticvolatileSingletoninstance;privateSingleton(){}publicstaticSingletongetInstance(){if(instance==null){synchronized(Singleton.class){if(instance==null){instance=newSingleton();}}}returninstance;}}```**优点**：线程安全，延迟加载，性能较好（只在第一次创建实例时加锁）。**注意**：必须使用`volatile`，因为`newSingleton()`不是一个原子操作（可能发生指令重排序导致部分初始化）[^5]。###(5)静态内部类（StaticInnerClass）利用静态内部类在第一次使用时加载的特性实现延迟加载和线程安全。```javapublicclassSingleton{privateSingleton(){}privatestaticclassHolder{privatestaticfinalSingletonINSTANCE=newSingleton();}publicstaticSingletongetInstance(){returnHolder.INSTANCE;}}```**优点**：线程安全（JVM保证类加载时初始化安全），延迟加载，实现简洁[^3]。###(6)枚举（Enum）由Java语言规范保证单一实例，且防止反射和序列化破坏单例。```javapublicenumSingleton{INSTANCE;//枚举常量就是单例实例publicvoiddoSomething(){//方法实现}}//调用方式：Singleton.INSTANCE.doSomething();```**优点**：线程安全，防止反射攻击，自动处理序列化和反序列化问题[^2]。**缺点**：不能延迟加载（枚举常量在类加载时就被初始化）。##3.面试中的常见问题-**线程安全**：为什么懒汉式不安全？如何改进？（参考双重检查锁和静态内部类）-**反射破坏**：如何防止反射创建多个实例？（枚举法天然防止；其他方式可在构造器检查已有实例）-**序列化破坏**：如何保证序列化和反序列化不会创建新实例？（实现`readResolve`方法或使用枚举）-**性能优化**：双重检查锁中`volatile`的作用？（避免指令重排序导致其他线程获取到部分初始化的对象）[^5]-**单例模式的使用场景**：例如数据库连接池、全局配置管理、日志记录器等。##4.面试考察点面试官可能要求：-写出两种或以上实现方式（例如饿汉式和双重检查锁）-解释每种方式的优缺点-在多线程环境下如何保证安全-如何避免反射和序列化破坏单例（高级问题）##§§相关问题§§为帮助您准备面试，我准备了以下相关问题：1.Java中如何通过反射破坏单例模式？枚举实现为什么能防止反射攻击？2.在双重检查锁中不使用`volatile`会有什么问题？如何验证？3.单例模式在多线程环境下的性能测试方法？4.单例模式在Spring框架中如何应用？（如通过`@Bean`创建的Bean是否是单例？）5.饿汉式单例能否被序列化破坏？如何防止？</think> ### 单例模式的定义及面试考察解析 单例模式是一种创建型设计模式，**确保一个类仅有一个实例，并提供全局访问点**。其核心是通过私有构造器防止外部实例化，通过静态方法控制唯一实例的访问，主要用于资源共享场景（如数据库连接池、配置管理）[^1]。 #### 面试考察重点 1. **实现能力**：要求手写至少两种实现方式（如饿汉式、懒汉式） 2. **线程安全理解**：解释多线程环境下的实例化风险及解决方案 3. **设计决策**：对比不同实现方案的优缺点 4. **扩展问题**：反射/序列化破坏的防护措施 --- ### 5种单例模式实现及面试解析 #### 1. 饿汉式（Eager Initialization） ```java public class Singleton { // 类加载时直接初始化（线程安全） private static final Singleton INSTANCE = new Singleton(); private Singleton() {} // 私有构造器 public static Singleton getInstance() { return INSTANCE; } } ``` **面试要点**： - ✅ **优点**：实现简单，线程安全（JVM保证类加载原子性） - ❌ **缺点**：非延迟加载，可能造成资源浪费 - 💡 **适用场景**：初始化开销小的轻量级对象[^4] #### 2. 懒汉式（Lazy Initialization） ```java public class Singleton { private static Singleton instance; private Singleton() {} // 基础版（线程不安全） public static Singleton getInstance() { if (instance == null) { instance = new Singleton(); // 多线程下可能创建多次 } return instance; } } ``` **面试考点**： - ⚠️ **核心问题**：竞态条件（Race Condition） - 🛡️ **改进方案**：添加`synchronized`（但会带来锁开销） - ❓ **典型提问**：*"如何优化同步带来的性能损耗？"* #### 3. 双重检查锁（Double-Checked Locking） ```java public class Singleton { private static volatile Singleton instance; // 必需volatile private Singleton() {} public static Singleton getInstance() { if (instance == null) { // 第一次检查避免不必要锁 synchronized (Singleton.class) { if (instance == null) { // 第二次检查确保单例 instance = new Singleton(); } } } return instance; } } ``` **面试重点**： - 🔑 **volatile作用**：禁止指令重排序，防止返回半初始化对象 - 📉 **内存模型问题**：Java 5前该方案存在可见性问题[^5] - 💬 **高频问题**：*"为什么要双重检查？volatile在此场景的必要性？"* #### 4. 静态内部类（Static Inner Class） ```java public class Singleton { private Singleton() {} // 静态内部类在首次访问时加载 private static class Holder { static final Singleton INSTANCE = new Singleton(); } public static Singleton getInstance() { return Holder.INSTANCE; // 线程安全由类加载机制保证 } } ``` **面试优势**： - ✅ **最佳实践**：延迟加载+无锁线程安全（推荐方案） - 🔒 **安全机制**：JVM类加载器保证初始化原子性[^3] - 💡 **对比问题**：*"相比双重检查锁有哪些优势？"* #### 5. 枚举实现（Enum） ```java public enum Singleton { INSTANCE; // 单例实例 public void doSomething() { System.out.println("执行操作"); } } // 调用：Singleton.INSTANCE.doSomething(); ``` **面试亮点**： - 🛡️ **绝对防护**：天然防止反射和序列化破坏（JVM层保证） - 📜 **规范推荐**：Joshua Bloch在《Effective Java》中的首选方案[^2] - ❓ **深度问题**：*"枚举实现为什么能防御反射攻击？"* --- ### 面试扩展问题解析 1. **线程安全验证** - 测试方法：通过`ExecutorService`创建多线程循环调用`getInstance()` - 检测手段：对比实例`hashCode()`是否一致 2. **反射破坏防护** 解决方案（非枚举类）： ```java private Singleton() { if (instance != null) { // 防止反射调用构造器 throw new IllegalStateException(); } } ``` 3. **序列化破坏防护** 解决方案： ```java // 添加readResolve方法 protected Object readResolve() { return getInstance(); } ``` --- ### 实现方案对比表 | 实现方式 | 线程安全 | 延迟加载 | 防反射 | 防序列化 | 性能 | |------------------|----------|----------|--------|----------|--------| | 饿汉式 | ✅ | ❌ | ❌ | ❌ | ⭐⭐⭐⭐ | | 同步懒汉式 | ✅ | ✅ | ❌ | ❌ | ⭐⭐ | | 双重检查锁 | ✅ | ✅ | ❌ | ❌ | ⭐⭐⭐⭐ | | 静态内部类 | ✅ | ✅ | ❌ | ❌ | ⭐⭐⭐⭐ | | **枚举** | ✅ | ❌ | ✅ | ✅ | ⭐⭐⭐⭐⭐ | > 📌 **面试建议**：优先掌握枚举和静态内部类实现，重点解释`volatile`在双重检查中的作用[^5]，并准备实际应用案例（如配置管理器） --- ###
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

穿城大饼

你的鼓励将是我最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值