常见的单例模式实现-CSDN博客

本文链接：https://blog.csdn.net/liutao0124/article/details/139296510

什么是单例模式

单例模式是一种常见的软件设计模式。通过单例模式实现在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个获得其对象实例的方法（静态方法）。

懒汉式（静态变量，推荐）


namespace ConsoleApp3
{

    namespace ConsoleApp3
    {
        class Singleton
        {
            /// <summary>
            /// 显式的静态构造函数用来告诉C#编译器在其内容实例化之前不要标记其类型
            /// </summary>
            static Singleton() { }

            // 1.构造器私有化
            private Singleton() { }

            // 2.本类的内部创建对象实例
            private static readonly Singleton instance = new Singleton();

            // 3.暴露一个公有的静态方法，返回实例对象
            public static Singleton getInstance()
            {
                return instance;
            }
        }

    }



}

优点：写法简单，在类装载的时完成实例化，避免了线程同步问题

缺点：类装载时完成实例化，没有达到LazyLoading的效果，若该实例从未使用，则会造成内存浪费

懒汉式（线程不安全，不推荐）


namespace ConsoleApp3
{
    class Singleton
    {

        // 1.构造器私有化
        private Singleton() { }

        // 2.静态属性，存放本类对象
        private static Singleton instance;

        // 3.静态的公有方法，当使用到该方法时才会去创建instance
        public static Singleton getInstance()
        {
            // 当静态属性没有被赋值的时候再去创建
            if (instance == null)
            {
                instance = new Singleton();
            }
            // 如果这个静态属性被初始化过了，就直接返回，保证是单例的
            return instance;
        }
    }


}

优点：起到了懒加载效果，但是只能在单线程使用。

缺点：多线程会不安全，因为当多个线程并发同时判断instance为空时，就会相应的实例化多个对象。

单锁模式（线程安全，不推荐）


namespace ConsoleApp3
{
    public sealed class Singleton
    {
        private static Singleton instance = null;
        private static readonly object _lock = new object();

        private Singleton() { }
        public static Singleton Instance
        {
            get
            {
                lock (_lock)
                {
                    if (instance == null)
                        instance = new Singleton();
                    return instance;
                }
            }
        }
    }


}

优点：线程安全

缺点：每次都需要判断锁，性能低

双层验证（推荐）


namespace ConsoleApp3
{
    public sealed class Singleton
    {
        private volatile  static Singleton instance = null;
        private static readonly object _lock = new object();

        private Singleton() { }
        public static Singleton Instance
        {
            get
            {
                if(instance == null)
                {
                    lock (_lock)
                    {
                        if (instance == null)
                            instance = new Singleton();
                    }
                }
                return instance;

            }
        }
    }


}

优点：线程安全且通过双null判断，减少进锁的逻辑，提高性能。

静态内部类（线程安全，推荐）


namespace ConsoleApp3
{
    namespace ConsoleApp3
    {
        class Singleton
        {
            private static volatile Singleton instance;
            private Singleton() { }
            //静态内部类,包含一个静态属性：Singleton
            private static class SingletonInstance
            {
                internal static readonly Singleton INSTANCE = new Singleton();
            }

            //对外公有的静态方法，直接返回SingletonInstance.INSTANCE
            public static  Singleton getInstance()
            {
                return SingletonInstance.INSTANCE;
            }
        }
    }
}

优点：简单、线程安全。

Lazy泛型

public sealed class Singleton
{
    private static readonly Lazy<Singleton> lazy =
        new Lazy<Singleton>(() => new Singleton());
 
    public static Singleton Instance { get { return lazy.Value; } }
 
    private Singleton()
    {
    }
}