单例模式-基础说明及Lazy源码解析

已于 2023-06-28 01:20:56 修改
阅读量92 收藏
点赞数
分类专栏： 设计模式 文章标签： 单例模式 c# 设计模式
于 2023-06-27 14:18:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JaxRunboo/article/details/131415927
版权

定义

单例模式是指在整个应用中，只有一个实例对象的设计模式。

为什么

实际上，单例模式是结合实际的场景进行的设计。比如，一个人只能有一个女朋友。那么我们在设计女友这个类的时候，她只能是单例的。

优点

  1. 一定程度上节约系统资源，提高系统性能(因为不需要对某个类进行频繁的创建)
  2. 避免对共享资源的多重占用(例如文件管理对象)

可以考虑使用单例模式的情况

  1. 需要高频使用的类
  2. 创建对象时消耗资源过多、消耗时间过长，且需要高频使用
  3. 有状态的工具类
  4. 频繁访问数据库或者文件

常见场景

  1. 日志管理、应用配置
  2. 线程池
  3. 数据库连接池
  4. HttpApplication

简单实现

实现关键点

  1. 实例化后的唯一实体
  2. 私有静态构造函数(私有函数定义好后，无法再通过new创建新的实体)
  3. 外部获取唯一实体的途径(提供给外界一个唯一的出口，访问我的唯一实体)

饿汉式

说明这个类的创建过程比较饥渴，所以在类加载的时候就被创建成功了。

using System;
namespace Test.single
{
    public class HungrySingle
    {
        //1. 类加载时被创建，只实例化一次，无线程安全问题
        private static readonly HungrySingle _instance = new HungrySingle();

        //2. 通过这个私有的静态构造函数，HungrySingle这个类无法通过new进行实例化
        private HungrySingle()
        {

        }

        // //3. 方法
        // public static HungrySingle getInstance()
        // {
        //     return _instance;
        // }

        //3. 访问器的方式 两者皆可
        public static HungrySingle instance
        {
            get
            {
                return _instance;
            }
        }
    }
}

懒汉式

意思是类的创建过程是非饥渴的，所以可以在请求获取实例方法的时候进行初始化。
但是懒汉式往往伴随着问题产生。

最基础的懒汉式代码
using System;
namespace Test.single
{
    public class LazySingle
    {
        private static LazySingle _instance;

        private LazySingle()
        {

        }


        public static LazySingle Instance
        {
            get
            {
                //此处在多线程情况下存在线程安全问题,instance是临界区
                if(_instance == null)
                {
                    _instance = new LazySingle();
                }
                return _instance;
            }
        }

    }
}

这段代码中的_instance作为多线程的临界资源，是存在线程安全的问题的。为了解决这个问题，可以通过加锁来实现。

双检锁实现

最简单的方式可以是加锁，然后锁内判断是否存在。更优的加锁方式是双检锁。

using System;
namespace Test.single
{
    public class DoubleCheckLockSingle
    {
        //保证每次获取此参数都是直接读取，而不是相信系统缓存
        private static volatile DoubleCheckLockSingle _instance;

        private static readonly object locker = new object();

        private DoubleCheckLockSingle() { }

        public static DoubleCheckLockSingle Instance
        {
            get
            {
                //判断 提升效率：原因如果某线程提前确认_instance已经存在，无需再次加锁
                if (_instance == null)
                {
                    //lock + 判断 ，保证线程安全
                    lock (locker)
                    {
                        if (_instance == null)
                        {
                            _instance = new DoubleCheckLockSingle();
                        }
                    }
                }
                return _instance;
            }
        }
    }
}

使用双检锁的懒汉单例有两个关键点：

  1. volatile字段

可以确保变量在访问过程中的可见性，即并发情况下，某线程的操作修改了volatile修改的属性，其他线程获取到的结果是更新后的结果。无这个关键词描述的情况下，获得的结果实际上还是修改前的结果。这属于线程的可见性问题。

  1. 双检锁

第一个if，用来提升性能。lock和第二个if才是实现线程安全的保障。

已封装好的Lazy实现

还有一个更简单的实现方式，Lazy

using System;
namespace Test.single
{
    public class EasyLazySIngle
    {
        private static readonly Lazy<EasyLazySIngle> _instance = new Lazy<EasyLazySIngle>(() => new EasyLazySIngle());

        private EasyLazySIngle() { }

        public EasyLazySIngle Instance
        {
            get
            {
                return _instance.Value;
            }
        }

    }
}

Lazy的内部实现也使用了双检锁，没有线程安全问题。

Lazy源码解析

源码如下：

using System;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Threading;

public class Lazy<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] T>
{
    //当前实例的状态，使用volatile,保证多线程的可见性
    //new LazyHelper(state)
    private volatile LazyHelper _state;

    // () => new T
    private Func<T> _factory;

    //实例的值
    private T _value;


    internal LazyThreadSafetyMode? Mode => LazyHelper.GetMode(_state);

    internal bool IsValueFaulted => LazyHelper.GetIsValueFaulted(_state);

    public bool IsValueCreated => _state == null;

    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    public T Value
    {
        get
        {
            if (_state != null) 
            {
                return CreateValue();
            }
            return _value;
        }
    }

    //实际使用
    //LazyThreadSafetyMode.ExecutionAndPublication  这个锁类型用来保证只有一个线程能够初始化实例
    public Lazy(Func<T> valueFactory)
        : this(valueFactory, LazyThreadSafetyMode.ExecutionAndPublication, useDefaultConstructor: false)
    {
    }


    private Lazy(Func<T> valueFactory, LazyThreadSafetyMode mode, bool useDefaultConstructor)
    {
        if (valueFactory == null && !useDefaultConstructor)
        {
            throw new ArgumentNullException("valueFactory");
        }
        _factory = valueFactory;
        _state = LazyHelper.Create(mode, useDefaultConstructor);
    }

    private void ViaFactory(LazyThreadSafetyMode mode)
    {
        try
        {
            Func<T> factory = _factory;
            if (factory == null)
            {
                throw new InvalidOperationException(SR.Lazy_Value_RecursiveCallsToValue);
            }
            _factory = null;
            _value = factory();//初始化
            _state = null;//这就锁内把_state清理掉了，即使多线程锁在同一个地方，下一个线程获得锁进来后，_state已经与当前获得的executionAndPublication不同了，也不会继续执行了
            //保证了线程安全
        }
        catch (Exception exception)
        {
            _state = new LazyHelper(mode, exception);
            throw;
        }
    }

    private void ExecutionAndPublication(LazyHelper executionAndPublication, bool useDefaultConstructor)
    {
        //对_state加锁
        lock (executionAndPublication)
        {
            //第二次判断 判断的是多线程是否导致了变化
            if (_state == executionAndPublication)
            {
                if (useDefaultConstructor)
                {
                    ViaConstructor();
                }
                else
                {
                    ViaFactory(LazyThreadSafetyMode.ExecutionAndPublication);
                }
            }
        }
    }


    private T CreateValue()
    {
        //开始考虑多线程
        LazyHelper state = _state;
        //第一次为空判断
        if (state != null)
        {
            switch (state.State)
            {
                case LazyState.NoneViaConstructor:
                    ViaConstructor();
                    break;
                case LazyState.NoneViaFactory:
                    ViaFactory(LazyThreadSafetyMode.None);
                    break;
                case LazyState.PublicationOnlyViaConstructor:
                    PublicationOnlyViaConstructor(state);
                    break;
                case LazyState.PublicationOnlyViaFactory:
                    PublicationOnlyViaFactory(state);
                    break;
                case LazyState.PublicationOnlyWait:
                    PublicationOnlyWaitForOtherThreadToPublish();
                    break;
                case LazyState.ExecutionAndPublicationViaConstructor:
                    ExecutionAndPublication(state, useDefaultConstructor: true);
                    break;
                    //命中
                case LazyState.ExecutionAndPublicationViaFactory:
                    ExecutionAndPublication(state, useDefaultConstructor: false);
                    break;
                default:
                    state.ThrowException();
                    break;
            }
        }
        return Value;
    }
}
  1. 私有属性 _state 含义为当前实例化对象的状态，也是锁的对象。
  2. _factory： 待执行函数，按照我们的Lazy使用方式，此处_factory = new T();
  3. _value: 实例化的实体

我们从Lazy的构造函数开始分析：
第一步，调用构造函数：

 //实际使用
//LazyThreadSafetyMode.ExecutionAndPublication  这个锁类型用来保证只有一个线程能够初始化实例
public Lazy(Func<T> valueFactory)
    : this(valueFactory, LazyThreadSafetyMode.ExecutionAndPublication, useDefaultConstructor: false)
{
}


private Lazy(Func<T> valueFactory, LazyThreadSafetyMode mode, bool useDefaultConstructor)
{
    if (valueFactory == null && !useDefaultConstructor)
    {
        throw new ArgumentNullException("valueFactory");
    }
    _factory = valueFactory;
    //通过调用LazyHelper的Create方法，初始化_state状态
    _state = LazyHelper.Create(mode, useDefaultConstructor);
}

LazyHelper的源码如下：

using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.ExceptionServices;
using System.Threading;

internal sealed class LazyHelper
{
    internal static readonly LazyHelper NoneViaConstructor = new LazyHelper(LazyState.NoneViaConstructor);

    internal static readonly LazyHelper NoneViaFactory = new LazyHelper(LazyState.NoneViaFactory);

    internal static readonly LazyHelper PublicationOnlyViaConstructor = new LazyHelper(LazyState.PublicationOnlyViaConstructor);

    internal static readonly LazyHelper PublicationOnlyViaFactory = new LazyHelper(LazyState.PublicationOnlyViaFactory);

    internal static readonly LazyHelper PublicationOnlyWaitForOtherThreadToPublish = new LazyHelper(LazyState.PublicationOnlyWait);

    private readonly ExceptionDispatchInfo _exceptionDispatch;

    internal LazyState State { get; }

    //LazyState.ExecutionAndPublicationViaFactory 本次使用模式
    internal LazyHelper(LazyState state)
    {
        State = state;
    }

    internal LazyHelper(LazyThreadSafetyMode mode, Exception exception)
    {
        switch (mode)
        {
            case LazyThreadSafetyMode.ExecutionAndPublication:
                State = LazyState.ExecutionAndPublicationException;
                break;
            case LazyThreadSafetyMode.None:
                State = LazyState.NoneException;
                break;
            case LazyThreadSafetyMode.PublicationOnly:
                State = LazyState.PublicationOnlyException;
                break;
        }
        _exceptionDispatch = ExceptionDispatchInfo.Capture(exception);
    }


    internal static LazyHelper Create(LazyThreadSafetyMode mode, bool useDefaultConstructor)
    {
        switch (mode)
        {
            case LazyThreadSafetyMode.None:
                if (!useDefaultConstructor)
                {
                    return NoneViaFactory;
                }
                return NoneViaConstructor;
            case LazyThreadSafetyMode.PublicationOnly:
                if (!useDefaultConstructor)
                {
                    return PublicationOnlyViaFactory;
                }
                return PublicationOnlyViaConstructor;
            //命中 LazyState.ExecutionAndPublicationViaFactory
            case LazyThreadSafetyMode.ExecutionAndPublication:
                {
                    LazyState state = (useDefaultConstructor ? LazyState.ExecutionAndPublicationViaConstructor : LazyState.ExecutionAndPublicationViaFactory);
                    return new LazyHelper(state);
                }
            default:
                throw new ArgumentOutOfRangeException("mode", SR.Lazy_ctor_ModeInvalid);
        }
    }
}

由此可知，_state中的数据为 LazyHelper的实例。此时基础准备已经构造完成。
我们从中可以看出，实际上需要的T的实例化并没有执行。他的实例化被后移到了调用时。

第二步，调用Value,实例化并返回

private T CreateValue()
{
    //开始考虑多线程
    LazyHelper state = _state;
    if (state != null)
    {
        switch (state.State)
        {
            case LazyState.NoneViaConstructor:
                ViaConstructor();
                break;
            case LazyState.NoneViaFactory:
                ViaFactory(LazyThreadSafetyMode.None);
                break;
            case LazyState.PublicationOnlyViaConstructor:
                PublicationOnlyViaConstructor(state);
                break;
            case LazyState.PublicationOnlyViaFactory:
                PublicationOnlyViaFactory(state);
                break;
            case LazyState.PublicationOnlyWait:
                PublicationOnlyWaitForOtherThreadToPublish();
                break;
            case LazyState.ExecutionAndPublicationViaConstructor:
                ExecutionAndPublication(state, useDefaultConstructor: true);
                break;
                //命中
            case LazyState.ExecutionAndPublicationViaFactory:
                ExecutionAndPublication(state, useDefaultConstructor: false);
                break;
            default:
                state.ThrowException();
                break;
        }
    }
    return Value;
}

private void ExecutionAndPublication(LazyHelper executionAndPublication, bool useDefaultConstructor)
{
    //对_state加锁
    lock (executionAndPublication)
    {
        //第二次判断 判断的是多线程是否导致了变化
        if (_state == executionAndPublication)
        {
            if (useDefaultConstructor)
            {
                ViaConstructor();
            }
            else
            {
                ViaFactory(LazyThreadSafetyMode.ExecutionAndPublication);
            }
        }
    }
}

private void ViaFactory(LazyThreadSafetyMode mode)
{
    try
    {
        Func<T> factory = _factory;
        if (factory == null)
        {
            throw new InvalidOperationException(SR.Lazy_Value_RecursiveCallsToValue);
        }
        _factory = null;
        _value = factory();//初始化
        _state = null;//这就锁内把_state清理掉了，即使多线程锁在同一个地方，下一个线程获得锁进来后，_state已经与当前获得的executionAndPublication不同了，也不会继续执行了
        //保证了线程安全
    }
    catch (Exception exception)
    {
        _state = new LazyHelper(mode, exception);
        throw;
    }
}

这三个方法进行顺序调用，最终的结果就是：
T进行实例化，并保存到_value中。_state和_factory被清理。

那么为什么说他也使用了双检锁呢？
首先，双检锁的执行循序是：

  1. 判断是否实例化
  2. 对某对象加锁
  3. 再次判断是否进行实例化

而在我们的源码中，结合我的注释可以看到，Lazy执行了类似的逻辑：

  1. 第一次判断state是否为空
  2. 对state加锁
  3. 第二次判断state是否与_state相等
JaxRunboo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅谈spring中的default-lazy-init参数和lazy-init
08-30
下面小编就为大家带来一篇浅谈spring中的default-lazy-init参数和lazy-init。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
利用Lazy简化单例模式的编写
乐征skyline
11-26 269
相信大部分Java开发者在工作中都用到过单例模式（即便这个设计模式并不是一个让人称道的模式），对于饿汉式的编写还好，双检锁懒汉式的编写就比较繁琐了。本文就提供一种简化方式。
单例模式：二-懒汉模式（Lazy）
ciaty40822的专栏
07-30 569
原文： Gerrard_Feng 二：2-懒汉模式（Lazy） 思想：相比于饿汉模式，懒汉模式实际中的应用更多，因为在系统中，“被用到时再初始化”是更佳的解决方案。 　　设计思想与饿汉模式类似，同样是持有一个自身的引用，只是将 new 的动作延迟到 getinstance() 方法中执行...
Lazy<T>的使用方式（可实现单例模式）
weixin_34381687的博客
05-30 800
Lazy&lt;T&gt;是延迟对象，通过它可以延迟创建T对象，也就是说，虽然已经声明了对象，但是实际上只有在使用T对象的时候，才会去创建这个对象。如下代码：class MyClass { public MyClass() { Console.WriteLine("MyClass对象创建，其标识：{0}", this.GetH...
C# Lazy<T>实现单例模式
zhulongxi的博客
09-10 3234
private readonly static Lazy _instance = new Lazy(() => new StockTicker(GlobalHost.ConnectionManager.GetHubContext().Clients)); public static StockTicker Instance { get { return
3.单例模式之Lazy Initialization Holder Class模式
yj826299017的博客
03-25 1292
单例模式之Lazy Initialization Holder Class模式1.0 前面已经介绍过两种单例模式：饿汉式单例模式和懒汉式单例模式 点击前往单例模式之饿汉式单例模式 点击前往单例模式之懒汉式单例模式1.1本文的源码获取:点击下载(建议使用电脑下载,解压缩后将文件夹放入src即可)1.2代码场景:A、package内有AppConfig.properties文件。B、通过获取单例的Ap...
基于Vue的延迟加载插件vue-view-lazy
08-27
主要介绍了基于Vue的延迟加载插件vue-view-lazy，可以使图片或者其他资源进入可视区域后加载，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
lazy-snapping--master.zip_lazy-snapping
09-23
基于lazy-snapping的图片分割代码
ASP.NET设计模式-杨明军译(源码)
07-06
7.3.3　Lazy Loading和Proxy模式 7.3.4　Identity Map模式 7.3.5　Query Object模式 7.4　使用对象关系映射器 7.4.1　NHibernate 7.4.2　MS Entity Framework 7.4.3　ORM代码示例 7.5　小结 第8章　表示层 8.1　...
lazy-line-painter：Lazy Line Painter-用于SVG路径动画的现代JS库
02-26
懒人画家 用于SVG路径动画的现代JS库 | 入门 根据快速入门说明，可以轻松完成Lazy Line Painter的设置。 但是，如果您更需要GUI，请确保使用 。 专为SVG路径动画开发的免费...import LazyLinePainter from 'lazy-l
C#中单例模式最简单用法之Lazy
qq_37189288的博客
05-14 1037
例如下面这个类要实现单例模式，只需要增加一个Lazy并返回AppData的实例即可。 public class AppData { public static AppData Instance = new Lazy<AppData>(() => new AppData()).Value; public AppData(){} public void Method(){} } 怎么使用呢，如下获取单例 var instance = AppData.Instance;
Lazy<Object> 单例
a237428367的专栏
07-11 656
private static readonly Lazy _instance = new Lazy(() => Activator.CreateInstance(), true); public static Object Instance { get { return _instance.Value; } }
单例模式--Lazy & UnLazy
villare的博客
10-04 1590
单例模式–Lazy & UnLazy1.Lazy实现方式 1.1 一般方式 1.2 Synchronized方式 1.3 静态内部类 2.UnLazy实现方式单例模式 1.单例类只有一个实例 2.单例类的唯一一个实例由自己创建 3.单例类的唯一一个实例能提供给其他外部内单例模式一般运用在实例对象初始化费时或者只需要一个的情况，如logger,printer等；Lazy 一般方式类中
Java实现单例的几种方式
weixin_34315485的博客
03-30 1762
1. 什么是单例模式 单例模式指的是在应用整个生命周期内只能存在一个实例。单例模式是一种被广泛使用的设计模式。他有很多好处，能够避免实例对象的重复创建，减少创建实例的系统开销，节省内存。 2. 单例模式和静态类的区别 首先理解一下什么是静态类，静态类就是一个类里面都是静态方法和静态field，构造器被private修饰，因此不能被实例化。...
【设计模式】单例模式（创建型）⭐⭐⭐
qq_43196617的博客
06-03 981
单例模式属于创建型模式，一个单例类在任何情况下都只存在一个实例构造方法必须是私有的、由自己创建一个静态变量存储实例，对外提供一个静态公有方法获取实例。
设计模式之单例模式
Java领域优秀创作者
06-02 794
单例模式（Singleton）是一种创建型设计模式，确保一个类在系统中仅有一个实例，并提供全局访问点。适用于需要唯一实例、节省资源、全局访问点和状态共享的场景。实现方式包括双重检查锁定、静态内部类和枚举等，每种方式有其优缺点，如线程安全、实现复杂度和反射攻击防范等。实际应用中，如配置管理、日志记录和数据库连接池等场景，通过单例模式实现统一管理和资源节约。同时，需注意线程安全、序列化与反序列化、防反射攻击等问题，以保证单例模式的有效性和安全性。
单例模式（C语言）
AZhi
05-30 357
单例模式（Singleton Pattern）是一种设计模式，目的是确保一个类只有一个。确保了在创建实例的过程中只有一个线程能够访问临界区，从而避免了多个实例的创建。以上是一个比较具体的例子。文章参考：[C语言和设计模式（之单件模式）]互斥锁（mutex）
设计模式-单例模式（创建型）
最新发布
qq_43676797的博客
06-05 274
单例模式是一种创建型设计模式，它提供了一种创建对象的最佳方式;
vue-lazyload的demo源码
03-29
以下是一个使用Vue-Lazyload的demo源码： index.html： ```html <!DOCTYPE html> <meta charset="UTF-8"> <title>Vue-Lazyload Demo <li v-for="(item, index) in list" :key="index"> <img v-lazy=...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值