为什么大厂面试官喜欢问单例模式

已于 2023-12-04 11:10:20 修改
阅读量156 收藏
点赞数
文章标签： 单例模式 java 开发语言
于 2022-12-11 00:31:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NVG_Haru/article/details/128271083
版权

单例模式的五种实现看似丧心病狂，其实是一个由浅入深，再到化繁为简的过程。

什么是单例模式

单例模式(Singleton Pattern，也称为单件模式)，使用最广泛的设计模式之一。其意图是保证一个类仅有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。

定义一个单例类：

私有化它的构造函数，以防止外界创建单例类的对象；
使用类的私有静态指针变量指向类的唯一实例；
使用一个公有的静态方法获取该实例。

懒汉版（Lazy Singleton）

教学版，即懒汉版（Lazy Singleton）：单例实例在第一次被使用时才进行初始化，这叫做延迟初始化。

// version 1.0
class Singleton
{
private:
	static Singleton* instance;
private:
	Singleton() {};
	~Singleton() {};
	Singleton(const Singleton&);
	Singleton& operator=(const Singleton&);
public:
	static Singleton* getInstance() 
        {
		if(instance == NULL) 
			instance = new Singleton();
		return instance;
	}
};

// init static member
Singleton* Singleton::instance = NULL;

问题1：Lazy Singleton存在内存泄露的问题，有两种解决方法：

使用智能指针
使用静态的嵌套类对象
对于第二种解决方法，代码如下：

// version 1.1
class Singleton
{
private:
	static Singleton* instance;
private:
	Singleton() { };
	~Singleton() { };
	Singleton(const Singleton&);
	Singleton& operator=(const Singleton&);
private:
	class Deletor {
	public:
		~Deletor() {
			if(Singleton::instance != NULL)
				delete Singleton::instance;
		}
	};
	static Deletor deletor;
public:
	static Singleton* getInstance() {
		if(instance == NULL) {
			instance = new Singleton();
		}
		return instance;
	}
};

// init static member
Singleton* Singleton::instance = NULL;

在程序运行结束时，系统会调用静态成员deletor的析构函数，该析构函数会删除单例的唯一实例。使用这种方法释放单例对象有以下特征：

在单例类内部定义专有的嵌套类。
在单例类内定义私有的专门用于释放的静态成员。
利用程序在结束时析构全局变量的特性，选择最终的释放时机。
在单例类内再定义一个嵌套类，总是感觉很麻烦。

问题2：这个代码在单线程环境下是正确无误的，但是当拿到多线程环境下时这份代码就会出现race condition，注意version 1.0与version 1.1都不是线程安全的。要使其线程安全，能在多线程环境下实现单例模式，我们首先想到的是利用同步机制来正确的保护我们的shared data。可以使用双检测锁模式（DCL: Double-Checked Locking Pattern）：

static Singleton* getInstance() {
	if(instance == NULL) {
		Lock lock;  // 基于作用域的加锁，超出作用域，自动调用析构函数解锁
        if(instance == NULL) {
        	instance = new Singleton();
        }
	}
	return instance;
}

注意，线程安全问题仅出现在第一次初始化（new）过程中，而在后面获取该实例的时候并不会遇到，也就没有必要再使用lock。双检测锁很好地解决了这个问题，它通过加锁前检测是否已经初始化，避免了每次获取实例时都要首先获取锁资源。

加入DCL后，其实还是有问题的，关于memory model。在某些内存模型中（虽然不常见）或者是由于编译器的优化以及运行时优化等等原因，使得instance虽然已经不是nullptr但是其所指对象还没有完成构造，这种情况下，另一个线程如果调用getInstance()就有可能使用到一个不完全初始化的对象。换句话说，就是代码中第2行：if(instance == NULL)和第六行instance = new Singleton();没有正确的同步，在某种情况下会出现new返回了地址赋值给instance变量而Singleton此时还没有构造完全，当另一个线程随后运行到第2行时将不会进入if从而返回了不完全的实例对象给用户使用，造成了严重的错误。在C++11没有出来的时候，只能靠插入两个memory barrier（内存屏障）来解决这个错误，但是C++11引进了memory model，提供了Atomic实现内存的同步访问，即不同线程总是获取对象修改前或修改后的值，无法在对象修改期间获得该对象。

因此，在有了C++11后就可以正确的跨平台的实现DCL模式了，利用atomic，代码如下：

atomic<Widget*> Widget::pInstance{ nullptr };
Widget* Widget::Instance() {
    if (pInstance == nullptr) { 
        lock_guard<mutex> lock{ mutW }; 
        if (pInstance == nullptr) { 
            pInstance = new Widget(); 
        }
    } 
    return pInstance;
}

C++11中的atomic类的默认memory_order_seq_cst保证了3、6行代码的正确同步，由于上面的atomic需要一些性能上的损失，因此我们可以写一个优化的版本：

atomic<Widget*> Widget::pInstance{ nullptr };
Widget* Widget::Instance() {
    Widget* p = pInstance;
    if (p == nullptr) { 
        lock_guard<mutex> lock{ mutW }; 
        if ((p = pInstance) == nullptr) { 
            pInstance = p = new Widget(); 
        }
    } 
    return p;
}

Best of All:

C++11规定了local static在多线程条件下的初始化行为，要求编译器保证了内部静态变量的线程安全性。在C++11标准下，《Effective C++》提出了一种更优雅的单例模式实现，使用函数内的 local static 对象。这样，只有当第一次访问getInstance()方法时才创建实例。这种方法也被称为Meyers’ Singleton。C++0x之后该实现是线程安全的，C++0x之前仍需加锁。

// version 1.2
class Singleton
{
private:
	Singleton() { };
	~Singleton() { };
	Singleton(const Singleton&);
	Singleton& operator=(const Singleton&);
public:
	static Singleton& getInstance() 
        {
		static Singleton instance;
		return instance;
	}
};
  1. 饿汉版（Eager Singleton）
    饿汉版（Eager Singleton）：指单例实例在程序运行时被立即执行初始化
// version 1.3
class Singleton
{
private:
	static Singleton instance;
private:
	Singleton();
	~Singleton();
	Singleton(const Singleton&);
	Singleton& operator=(const Singleton&);
public:
	static Singleton& getInstance() {
		return instance;
	}
}

// initialize defaultly
Singleton Singleton::instance;

由于在main函数之前初始化，所以没有线程安全的问题。但是潜在问题在于no-local static对象（函数外的static对象）在不同编译单元中的初始化顺序是未定义的。也即，static Singleton instance;和static Singleton& getInstance()二者的初始化顺序不确定，如果在初始化完成之前调用 getInstance() 方法会返回一个未定义的实例。

总结：

Eager Singleton 虽然是线程安全的，但存在潜在问题；
Lazy Singleton通常需要加锁来保证线程安全，但局部静态变量版本在C++11后是线程安全的；
局部静态变量版本（Meyers Singleton）最优雅。

饿汉式

饿汉式的实现思路是初始化的过程中就加载完成单例，而不是延迟再加载，有一种饥不择食的感觉，代码如下。

import java.util.concurrent.atomic.AtomicLong;

public class IdGen {
    private AtomicLong id = new AtomicLong(0);
    private static final IdGen instance = new IdGen();

    private IdGen() {
    }

    public static IdGen getInstance() {
        return instance;
    }

    public long getId() {
        var r = id.incrementAndGet();
        System.out.println(r);
        return r;

    }
}

这就适合一些业务加载时间长或者必须提前加载的使用场景。不少人觉得业务加载时间长应该延迟加载，这样才能加快启动速度。其实延迟加载会影响用户体验，因为延迟加载后，用户请求发过来，服务器还没加载完一直卡着响应，体验极差。

注意看，Runtime类中的单例模式是用饿汉式实现的。

/**
 * Every Java application has a single instance of class
 * <code>Runtime</code> that allows the application to interface with
 * the environment in which the application is running. The current
 * runtime can be obtained from the <code>getRuntime</code> method.
 * <p>
 * An application cannot create its own instance of this class.
 *
 * @author unascribed
 * @see java.lang.Runtime#getRuntime()
 * @since JDK1.0
 */
public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    public static Runtime getRuntime() {
        return currentRuntime;
    }

    /** Don't let anyone else instantiate this class */
    private Runtime() {
    }

    // ....
    public void addShutdownHook(Thread hook) {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            sm.checkPermission(new RuntimePermission("shutdownHooks"));
        }
        ApplicationShutdownHooks.add(hook);
    }
    // ...
}

懒汉式

最原始的懒汉式单例给方法加锁，实现延迟加载。但这种方法根本就不支持并发，是个串行操作。如果你用这种方法实现，一旦遇到并发的资源访问，系统根本hold不住，背锅概率99%。

import java.util.concurrent.atomic.AtomicLong;

public class IdGen {
    private AtomicLong id = new AtomicLong(0);
    private static IdGen instance;

    private IdGen() {
    }

    public static synchronized IdGen getInstance() {
        if (instance == null) {
            instance = new IdGen();
        }
        return instance;
    }

    public long getId() {
        var r = id.incrementAndGet();
        return r;

    }
}

双重检测

双重检测既实现了延迟加载，又支持了并发。不少人可能会疑惑，为什么要检测两次instance==null，原因其实很简单，如果只检测一次，假设两个线程调用getInstance()，其中一个线程new出了单例，另一个线程等待第一个释放锁之后仍然可以new出单例，那这就破坏了单例模式，因此需要检测两次。

有的人可能会说创建对象singleton = new Singleton()的底层是分为三个步骤：

  1. 为对象分配内存空间；
  2. 初始化对象；
  3. 对象地址的引用。

因此要给 instance 成员变量加上 volatile 关键字，禁止指令重排序才行。实际上，只有很低版本的 Java 才会有这个问题。我们现在用的高版本的 Java 已经在 JDK 内部实现中解决了这个问题（解决的方法很简单，只要把对象 new 操作和初始化操作设计为原子操作，就自然能禁止重排序）。

import java.util.concurrent.atomic.AtomicLong;

public class IdGen {
    private AtomicLong id = new AtomicLong(0);
    private static IdGen instance;

    private IdGen() {
    }

    public static IdGen getInstance() {
        if (instance == null) {
            synchronized (IdGen.class) {
                if (instance == null) {
                    instance = new IdGen();
                }
            }
        }
        return instance;
    }

    public long getId() {
        var r = id.incrementAndGet();
        return r;
    }
}

内部静态类

内部静态类的实现也实现了延迟加载，把并发的操作交给了JVM来处理，不过仍然有序列化和反射破坏单例模式的问题。

import java.util.concurrent.atomic.AtomicLong;

public class IdGen {
    private AtomicLong id = new AtomicLong(0);

    private IdGen() {
    }

    private static class SingletonHolder {
        private static final IdGen instance = new IdGen();
    }

    public static IdGen getInstance() {
        return SingletonHolder.instance;
    }

    public long getId() {
        var r = id.incrementAndGet();
        return r;
    }
}

枚举

枚举也是实现了延迟加载，并发交由JVM处理，并且没有序列化和破坏单例模式的问题，可以说是延迟加载中的最优解。

import java.util.concurrent.atomic.AtomicLong;

// 测试类直接调用IdGen.INSTANCE
public enum IdGen {
    INSTANCE;

    private AtomicLong id = new AtomicLong(0);

    public long getId() {
        var r = id.incrementAndGet();
        System.out.println(r);
        return r;
    }
}

总结

综上，我们不难发现单例大体可以分为提前加载和延迟加载两大类，饿汉式单例在指定的应用场景是无可替代的，枚举实现的单例简洁安全，双重检测能考察你对锁的理解，因此单例面试题深得面试官喜爱。

热爱技术的小胡
关注
专栏目录
我向面试官讲解了单例模式，他对我竖起了大拇指
2301_76348206的博客
05-03 955
作为过来人，小编是整理了很多进阶架构视频资料、面试文档以及PDF的学习资料，针对上面一套系统大纲小编也有对应的相关进阶架构视频资料ructor();// 可访问私有构造器// 利用反射构造新对象// 通过正常方式获取单例对象// false作为过来人，小编是整理了很多进阶架构视频资料、面试文档以及PDF的学习资料，针对上面一套系统大纲小编也有对应的相关进阶架构视频资料[外链图片转存中…(img-K00l90jo-1714707346815)]
【面试篇】手写单例模式及原理剖析
wanghuichen的博客
05-11 3648
面试官：手写一个单例模式，五种单例模式了解吗？
【026期】面试官：说说双重检查加锁单例模式为什么两次校验？
2401_83817343的博客
04-19 1059
i < 100;为什么是双重校验锁实现单例模式呢？也就是第一个if（singleton==null），这个是为了代码提高代码执行效率，由于单例模式只要一次创建实例即可，所以当创建了一个实例之后，再次调用getInstance方法就不必要进入同步代码块，不用竞争锁。直接返回前面创建的实例即可。也就是第二个if（singleton。
字节面试官问：写一个你认为最好的单例模式？于是我写了7个
2401_84437170的博客
04-19 839
在程序的初始化时，将多个单例类型注入到一个统一管理的类中，使用时根据key获取对象对应类型的对象。关键字修饰的属性，表示这个成员属于类本身，不属于实例，运行时，Java 虚拟机只为静态变量分配一次内存，在类加载的过程中完成静态变量的内存分配。只有在第一次请求实例的时候的时候创建，并且只在第一次创建后，以后不再创建该类的实例。前面在分析枚举类实现单例模式时，有提到一个问题，就是私有化构造，会被反射破坏，导致出现多实例问题。这种方式既保证线程安全，单例对象的唯一，也延迟了单例的初始化，
面向对象语言&大厂面试必问的单例设计模式——手撕七种单例模式
FullChair的博客
12-20 937
设计模式——手写八种单例模式前言+说明一、懒汉式加载1、非线程安全的懒汉式加载 前言+说明 ❤️旺仔兄弟们！这个是java语言编写的八种单例模式，总共两大类：饿汉式和懒汉式！ 如果觉得博主分享的不错，希望能留下您的一键❤️三连❤️（点赞+评论+收藏） ，您的支持就是我前进的动力❤️，您的三连对我特别重要。 注明：下述内容只用于学习交流所用，禁止用于商业销售。同时也希望旺仔兄弟们能提出改善文章的宝贵意见，期待与大家共同进步❤️！     这种模式涉及到一个单一的类，该
关键字static与单例模式的一点理解_有static为什么还要有单例模式
2401_85122951的博客
06-11 252
大厂面试问深度，小厂面试问广度，如果有同学想进大厂深造一定要有一个方向精通的惊艳到面试官，还要平时遇到问题后思考一下问题的本质，找方法解决是一个方面，看到问题本质是另一个方面。还有大家一定要有目标，我在很久之前就想着以后一定要去大厂，然后默默努力，每天看一些大佬们的文章，总是觉得只有再学深入一点才有机会，所以才有恒心一直学下去。
单例模式 C++
IT OR 考公？
02-12 1469
懒汉，饿汉，解决内存泄漏，双检锁，原子，C++11 magic static，模板类
详细理解单例模式与多线程+阿里面试题+面试心得，2024年最新面经怎么写
2401_84440307的博客
04-20 857
在这个部分总结了2019年到目前为止Java常见面试问题，取其面试核心编写成这份文档笔记，从中分析面试官的心理，摸清面试官的“套路”，可以说搞定90%以上的Java中高级面试没一点难度。本节总结的内容涵盖了：消息队列、Redis缓存、分库分表、读写分离、设计高并发系统、分布式系统、高可用系统、SpringCloud微服务架构等一系列互联网主流高级技术的知识点。（上述只是一个整体目录大纲，每个点里面都有如下所示的详细内容，从面试问题——分析面试官心理——剖析面试题——完美解答的一个过程）
单例模式（万字长文精讲）_我是如何用单例模式征服面试官的
2401_84166376的博客
04-20 754
简单来说，就是编译器和处理器会针对编译后的指令进行重新排序，这种重排序对应编译器和处理器来说是会带来一定的性能提升的，但是对于编写代码的程序员来说，如果不正确的使用同步语义，将会导致非预期结果出现。这种重排序，假设是在线程1执行中发生了，此时线程2执行到第20行 if (LAZY_SINGLETON == null)，此时LAZY_SINGLETON 并不为null，程序会直接返回LAZY_SINGLETON对象，但是此时的对象是一个实例化不完全的对象，这种情况是不允许存在的。
这怕是最全的【单例模式】，2024大厂Java面试真题集锦
m0_56169789的博客
03-15 1086
各位读者，由于本篇幅度过长，为了避免影响阅读体验，下面我就大概概括了整理了存中…(img-2ysc2YXZ-1710434840310)][外链图片转存中…(img-TBhvg2Nw-1710434840311)][外链图片转存中…(img-OlPdJZ7p-1710434840312)]由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）
面试官系统精讲Java源码及大厂真题.rar
12-29
Java语言是IT行业中广泛使用的编程语言，特别是在企业级应用开发中占据着主导地位...通过系统学习和练习这些Java源码和大厂面试题，不仅可以提升个人的编程能力，还能为面试做好充分准备，增加成功入职心仪公司的概率。
阿里java面试官问：写一个你认为最好的单例模式？怒写了7个
Java高级教程、Java架构师、Java进阶教程
04-25 415
面试题：写一个你认为最好的单例模式 面试考察点 考察目的： 单例模式可以考察非常多的基础知识，因此对于这种问题，很多面试官都会问。 小伙伴要注意，在面试过程中，但凡能够从多个维度考察求职者能力的题目，一定不会被抛弃，特别是比较泛的问题，比如： ”请你说说对xxx的理解“之类。 考察范围： 工作1到5年经验，随着经验的提升，对于该问题的考察深度越深。 好友添加：huany6880 加入资深Java学习交流圈，并有系统整理了一套java初学/进阶者最佳的学习方法以及路 线图大纲，Java各核心知识点、架构.
阿里面试官必问：说说双重检查加锁单例模式为什么两次判断？
Java后端架构V
05-31 458
为什么是双重校验锁实现单例模式呢？也就是第一个if（singleton==null），这个是为了提高代码执行效率，由于单例模式只要一次创建实例即可，所以当创建了一个实例之后，再次调用getInstance方法就不必要进入同步代码块，不用竞争锁。直接返回前面创建的实例即可。
设计模式-单例模式
最新发布
ZSS1753936255的博客
10-02 208
饿汉模式: 饿汉有饿又急，所以在类加载的过层中就 实例出了唯一对象 （当然，前提是清楚java 类加载过程）当一个类New出很多个实例且没有任何区别的时候，此时就没有必要New出多个实例了。单例模式：只保证一个类只有一个实例，并提供一个访问他的全局访问点。懒汉模式： 比较懒，只是在需要的时候，才会创建实例化。单例模式:有区分为懒汉模式和饿汉模式。
设计模式之单例模式
qq_39437730的博客
09-29 730
单例模式是一种简单而有效的设计模式，适用于需要确保类仅有一个实例的场景。然而，在使用时应考虑其可能带来的复杂性和测试难度，合理应用以获得最佳效果。
C++实现单例模式
weixin_45186425的博客
09-29 434
C++单例模式实现
继承实现单例模式的探索（一）
我与岁月的森林的博客
09-27 550
探索通过继承实现单例模式，而非代码内联。
深入理解JavaScript中的单例模式
"前端大厂最新面试题-Singleton Pattern.docx" 单例模式是软件设计模式中的重要概念，尤其在前端开发中常被用来保证一个类只有一个实例，并提供全局访问点。这种模式对于管理和共享资源非常有用，比如事件总线、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

热爱技术的小胡

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

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

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

打赏作者

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

抵扣说明：

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

余额充值