C#单例模式

在知乎看到一篇文章讲单例模式，挺不错的，转载过来记录一下

设计模式之单例模式 - 知乎 (zhihu.com)

单例模式的定义和应用场景就不赘诉了，这种模式主要的目的是在多线程场景下替换全局变量的方式，保证“全局”类只能实例一个对象，提供全局唯一访问点，所以我们的目标是为了学习如何实现一种单例模式可以保证线程安全。

过程：

1. 实现方式1：不是线程安全的。

namespace Singleton
{
    /// <summary>
    /// Singleton.
    /// </summary>
    public class Logger
    {
        private static Logger? _instance;

        public static Logger Instance
        {
            get
            {
                if (_instance == null)//当有两个线程同时跑到这里判断的时候，有可能会创建两个实例
                {
                    _instance = new Logger();
                }
                return _instance;
            }
        }

        protected Logger()
        {
        }

        /// <summary>
        /// SingletonOperation.
        /// </summary>
        /// <param name="message"></param>
        public void Log(string message)
        {
            Console.WriteLine($"Message to log: {message}");
        }
    }
}

2. 改进方式1：使用静态变量直接初始化

public static Logger Instance = new Logger();。这样类会在程序启动时立刻被初始化，并且只会初始化一次。这个方法不能实现延迟初始化，不太推荐使用。

3. 改进方式2：使用线程安全的延迟初始化类 Lazy<T>

Lazy<T>是.net内置的线程安全的延迟初始化类（.net4.0推出的），通过声明一个静态的 Lazy<T>类可以保证T类在使用的时候才开始创建实例。

namespace Singleton
{
    /// <summary>
    /// Singleton logger using Lazy feature.
    /// </summary>
    public class Logger
    {
        private static readonly Lazy<Logger> _lazyLogger
            = new Lazy<Logger>(() => new Logger());

        public static Logger Instance
        {
            get
            {
                return _lazyLogger.Value;
            }
        }

        private Logger()
        {
        }

        /// <summary>
        /// SingletonOperation
        /// </summary>
        /// <param name="message"></param>
        public void Log(string message)
        {
            Console.WriteLine($"Message to log: {message}");
        }
    }
}

4. 改进方式3：使用双重检查加锁机制 (Double-checked Locking) 

这种方式也很常见，是必须掌握的一种。

/// <summary>
    /// Singleton logger using double checked locking.
    /// </summary>
    public class Logger2
    {
        private static Logger2? _instance;
        private static readonly object _lock = new object();

        public static Logger2 Instance
        {
            get
            {
                if (_instance == null)//锁请求代码需要损耗资源，如果很多条线程冲到lock代码的时候不太好，所以最好还是多一层判断。
                {
                    lock(_lock)//保证只有一个线程访问下面两行代码
                    {
                        if (_instance == null)//此时如果线程2进入到这段代码时判断到不为空则不会再创建实例。
                        {
                            _instance = new Logger2();//线程1创建实例后释放锁，允许线程进行对实例进行判断。
                        }
                    }
                }
                return _instance;
            }
        }

        private Logger2()//防止不知道的人通过构造函数初始化
        {
        }

        /// <summary>
        /// SingletonOperation
        /// </summary>
        /// <param name="message"></param>
        public void Log(string message)
        {
            Console.WriteLine($"Message to log: {message}");
        }
    }

总结：

实现方式2和3必须要记住如何实现，至于为什么要这么写知道所以然就好了。