单例模式-C#

发布于:2024-07-17 ⋅ 阅读:(71) ⋅ 点赞:(0)

在C#中实现单例模式,主要目的是确保一个类仅有一个实例,并提供一个全局访问点来获取这个实例。以下是一个简单的单例模式实现示例,它使用了一个私有静态变量来保存类的唯一实例,并提供了一个公有的静态方法来获取这个实例。此外,还使用了私有构造函数来防止通过new关键字在类的外部创建实例。

单例模式的优点:

    1. 单例模式可以保证一个类只有一个实例,减少内存开销,降低系统的复杂度,并加强系统的稳定性。
    1. 单例模式可以避免对资源的多重占用,保证系统的一致性。
    1. 单例模式可以全局访问点,可以提供一个访问点,使得外界可以直接访问该实例。
    1. 单例模式可以提供一个统一的访问点,简化调用,提高代码的可读性和可维护性。

单例模式的缺点:

    1. 单例模式一般没有接口,扩展困难。
    1. 单例模式违反了依赖倒置原则,一个模块应该依赖于抽象,而不是具体的实现。
    1. 单例模式对测试不利,难以对单例进行单元测试。
    1. 单例模式在多线程环境下需要进行线程同步,可能会导致性能问题。
    1. 单例模式在一些框架中使用单例模式,可能会导致系统的复杂性。
    1. 单例模式在一些语言中不容易实现,比如Java中不能通过反射创建对象。
    1. 单例模式在一些场景下会增加系统的复杂度,比如多线程的应用场景。
    1. 单例模式在一些框架中使用单例模式,可能会导致系统的复杂性。
    1. 单例模式在一些语言中不容易实现,比如Java中不能通过反射创建对象。
    1. 单例模式在一些场景下会增加系统的复杂度,比如多线程的应用场景。

懒汉式(线程不安全)

这是最基本的实现方式,但在多线程环境下可能会创建多个实例。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SingletonPattern
{
    /// <summary>
    /// 懒汉式(线程不安全)
    /// 这是最基本的实现方式,但在多线程环境下可能会创建多个实例。
    /// </summary>
    internal class Singleton_LazyNoSafety
    {
        // 私有静态变量,用于存储类的唯一实例
        private static Singleton_LazyNoSafety instance;

        // 私有构造函数,防止外部创建实例  
        private Singleton_LazyNoSafety() 
        {
            Console.WriteLine("单例模式:懒汉式(线程不安全)!");
        }

        // 公有静态方法,返回类的唯一实例  
        public static Singleton_LazyNoSafety GetInstance()
        {
            // 如果实例不存在,则创建实例
            if (instance == null)
            {
                instance = new Singleton_LazyNoSafety();
            }
            return instance;
        }
    }
}

懒汉式(线程安全)

通过在GetInstance方法上添加lock关键字来确保线程安全。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SingletonPattern
{
    /// <summary>
    /// 懒汉式(线程安全)
    /// 通过在GetInstance方法上添加lock关键字来确保线程安全。
    /// </summary>
    public class Singleton_LazySafety
    {
        private static Singleton_LazySafety instance;

        /*
         * lock 关键字是用于同步代码块,确保在同一时间内只有一个线程可以执行该代码块。
         * lock 关键字通过锁定一个对象来工作,任何线程在尝试进入被 lock 保护的代码块之前,都必须先获得该对象的锁。
         * 如果一个线程已经获得了锁,其他线程就必须等待,直到锁被释放。当线程退出 lock 代码块时,无论是因为正常执行完毕还是由于异常退出,锁都会被自动释放。
         */
        private static readonly object lockObj = new object();
        private Singleton_LazySafety()
        {
            Console.WriteLine("单例模式:懒汉式(线程安全)!");
        }
        public static Singleton_LazySafety GetInstance()
        {
            lock (lockObj)
            {
                if (instance == null)
                {
                    instance = new Singleton_LazySafety();
                }
            }
            return instance;
        }
    }
}

饿汉式

这种方式基于类加载机制避免了多线程同步问题,但是在类装载时就完成实例化,没有达到Lazy Loading的效果。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SingletonPattern
{
    /// <summary>
    /// 饿汉式
    /// 这种方式基于类加载机制避免了多线程同步问题,但是在类装载时就完成实例化,没有达到Lazy Loading的效果。
    /// </summary>
    public class Singleton_Hungry
    {
        // 私有静态变量,用于存储类的唯一实例
        private static Singleton_Hungry instance;

        // 私有构造函数,防止外部创建实例  
        public Singleton_Hungry()
        {
            Console.WriteLine("单例模式:饿汉式!");//在类被加载时就会创建实例对象,不会被打印到控制台
        }

        // 公有静态方法,返回类的唯一实例  
        public static Singleton_Hungry GetInstance() 
        { 
            return instance; 
        }
    }
}

双重检查锁定(Double-Checked Locking)

这种方式既保证了线程安全,又避免了每次调用GetInstance时都进行同步,从而提高了性能。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SingletonPattern
{
    /// <summary>
    /// 双重检查锁定(Double-Checked Locking)
    /// 这种方式既保证了线程安全,又避免了每次调用GetInstance时都进行同步,从而提高了性能。
    /// </summary>
    public class Singleton_DoubleCheckedLocking
    {
        // 使用volatile关键字确保多线程环境下的可见性  
        private static volatile Singleton_DoubleCheckedLocking instance;
        private static readonly object lockObject = new object();
        private Singleton_DoubleCheckedLocking()
        {
            Console.WriteLine("单例模式:双重检查锁定!");
        }
        public static Singleton_DoubleCheckedLocking GetInstance()
        {
            // 第一次检查实例是否存在,如果不存在,才进入下面的同步块  
            if (instance == null)
            {
                lock (lockObject)
                {
                    // 第二次检查实例是否存在,防止多个线程都通过了第一次检查并创建实例  
                    if (instance==null)
                    {
                        instance = new Singleton_DoubleCheckedLocking();
                    }
                }
            }
            return instance;
        }
    }
}

.NET Framework 4.0及更高版本

请注意,在.NET Framework 4.0及更高版本中,由于System.Lazy的引入,实现单例模式变得更加简单和高效。Lazy类提供了一种延迟初始化的机制,它确保对象在其Value属性被访问之前不会被实例化。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SingletonPattern
{
    /// <summary>
    /// 4.0后高版本
    /// 在.NET Framework 4.0及更高版本中,由于System.Lazy<T>的引入,实现单例模式变得更加简单和高效。
    /// Lazy<T>类提供了一种延迟初始化的机制,它确保对象在其Value属性被访问之前不会被实例化。
    /// </summary>
    internal class Singleton_HighVersion
    {
        // 使用Lazy<T>实现单例模式  
        private static readonly Lazy<Singleton_HighVersion> lazy = new Lazy<Singleton_HighVersion>(() => new Singleton_HighVersion());

        // 私有构造函数  
        private Singleton_HighVersion()
        {
            Console.WriteLine("单例模式:4.0后高版本!");
        }

        // 公有静态属性,返回类的唯一实例  
        public static Singleton_HighVersion Instance => lazy.Value;
    }
}

调用结果

using System;

namespace SingletonPattern
{
    internal class Program
    {
        static void Main(string[] args)
        {

            var instance_lazy1 = Singleton_LazyNoSafety.GetInstance();
            var instance_lazy2 = Singleton_LazyNoSafety.GetInstance();
            // 比较内存地址判断是否同一个实例  
            Console.WriteLine(ReferenceEquals(instance_lazy1, instance_lazy2)); // 输出: True 


            var instance_lazy3 = Singleton_LazySafety.GetInstance();
            var instance_lazy4 = Singleton_LazySafety.GetInstance();
            Console.WriteLine(ReferenceEquals(instance_lazy3, instance_lazy4)); 


            //在类被加载时就会创建实例对象
            var instance_hungry1 = Singleton_Hungry.GetInstance();
            var instance_hungry2 = Singleton_Hungry.GetInstance();
            Console.WriteLine(ReferenceEquals(instance_hungry1, instance_hungry2));


            var instance_double1 = Singleton_DoubleCheckedLocking.GetInstance();
            var instance_double2 = Singleton_DoubleCheckedLocking.GetInstance();
            Console.WriteLine(ReferenceEquals(instance_double1, instance_double2));

            var instance_high1 = Singleton_HighVersion.Instance;
            var instance_hagh2 = Singleton_HighVersion.Instance;
            Console.WriteLine(ReferenceEquals(instance_high1, instance_hagh2));
        }
    }
}