asp.net中单例模式学习笔记

作者：袖梨 2022-06-25

定义：单例模式(SingletonPattern)，保证一个类仅有一个实例，并提供一个访问它的全局访问点。

其实就是实现只有一个门可以进入，且每次只给一个人进入。这就像以前的一位博友所举的例子，很多人排队去厕所蹲坑一样，每一次只能让一个人去蹲坑。实现单例模式的原因，要么是资源共享，要么是控制资源等。所谓资源共享，就是因为单例模式保证了一个类仅有一个实例，所以大家访问的实例是一致的。而控制资源的话，主要是减少资源的申请与释放等。

类型：创建型模式

类图：

概述:

在很多比较大型的程序中，全局变量经常被用到。如果不用全局变量，那么在使用到的模块中，都需要用参数将全局变量传入，这是非常麻烦的。虽然要减少使用全局变量，但是如果需要，还是要用。单例模式就是对传统的全局的一种改进。单例可以做到延时实例化，即在需要的时候才进行实例化。针对一些大型的类，延时实例化是有好处的。

需要注意的是，在C#，Java中，有饿汉单例模式(即在声明变量的时候就初始化)和懒汉模式(在需要使用的时候再初始化)。而在GoF的书中，只讲到了懒汉模式，这是因为C++的静态变量在初始化时具有不确定性。同一个类中的静态变量初始化与其声明顺序一致，但是不同类中的静态变量初始化顺序却是不确定的。

另外在多线程中，需要注意访问的临界区，需要加Lock用以控制。

代码：添加了一个静态对象用来处理内存垃圾回收。

代码如下

复制代码

// C++
class CSingleton
{
    // 私有构造函数,不被允许直接构造对象
private:
    CSingleton()
    {
    }

public:
    static CSingleton* GetInstance()
    {
        if (NULL == m_pSingleton)
            m_pSingleton = new CSingleton();

        return m_pSingleton;
    }

    void SetIdx(int _nIdx)
    {
        m_nIdx = _nIdx;
    }

    int GetIdx()
    {
        return m_nIdx;
    }

private:
    int m_nIdx;

    static CSingleton* m_pSingleton;
public:
    class CRecycle
    {
    public:
        ~CRecycle()
        {
            if (NULL !=CSingleton::m_pSingleton)
            {
                deleteCSingleton::m_pSingleton;
            }
        }
    };
    static CRecycle m_recycle;
};

// 静态成员变量的初始化
CSingleton*CSingleton::m_pSingleton = NULL;
CSingleton::CRecycleCSingleton::m_recycle;

int _tmain(int argc,_TCHAR* argv[])
{
    CSingleton::GetInstance()->SetIdx(1);

return0;
}

第一种：简单实现（惰性实例化）

代码如下

复制代码

namespace Singleton
{
    public class Program
    {
        static void Main(string[] args)
        {
            Singleton s1 = Singleton.Instance;
            Singleton s2 = Singleton.Instance;

            if (s1 == s2)
            {
                Console.WriteLine("Objects are the same instance");
            }

            Console.Read();
        }
    }

    public sealed class Singleton
    {
        private Singleton() { }

private static Singleton instance = null;

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

简单实现对于线程来说是不安全的，因为在多线程的情况下，有可能产生多个Singleton实例。多线程的情况下，如果多个线程都去判断（instance == null），而它们都还没有创建实例的情况下，就会产生多个Singleton实例。对于简单实现来讲，Singleton实例化并不是应用程序启动就创建，所以我们把它叫做“惰性实例化”，这能避免应用程序启动时实例化不必要的实例。

第二种：安全的线程

代码如下

复制代码

namespace Singleton
{
    public class Program
    {
        static void Main(string[] args)
        {
            Singleton s1 = Singleton.Instance;
            Singleton s2 = Singleton.Instance;

            if (s1 == s2)
            {
                Console.WriteLine("Objects are the same instance");
            }

            Console.Read();
        }
    }

    public sealed class Singleton
    {
        private Singleton() { }

private static Singleton instance = null;
private static readonly object padLock = new object();

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

安全的线程，这是对简单实例的补充。因为提供了加锁lock()的操作，这就能确保只有一个线程进入。但是加锁需要增加额外的开销，损失性能。

第三种：双重锁定检查

代码如下

复制代码

namespace Singleton
{
    public class Program
    {
        static void Main(string[] args)
        {
            Singleton s1 = Singleton.Instance;
            Singleton s2 = Singleton.Instance;

            if (s1 == s2)
            {
                Console.WriteLine("Objects are the same instance");
            }

            Console.Read();
        }
    }

    public sealed class Singleton
    {
        public Singleton() { }

private static Singleton instance = null; private static readonly object padLock = new object();

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

双重锁定检查在安全的线程上面又进行了改进，主要是考虑了每次加锁会增加额外的开销，影响性能。所以在加锁前再判断Singleton有没有被实例化。这样，它就能减少很多的额外开销且是线程安全的。实际上，应用程序很少需要上面方式的实现。这种方式仍然有很多缺点：无法实现延迟初始化。大多数情况下我们会使用静态初始化的方式。

第四种：静态初始化

代码如下

复制代码

namespace Singleton
{
    public class Program
    {
        static void Main(string[] args)
        {
            Singleton s1 = Singleton.Instance;
            Singleton s2 = Singleton.Instance;

            if (s1 == s2)
            {
                Console.WriteLine("Objects are the same instance");
            }

            Console.Read();
        }
    }

    public sealed class Singleton
    {
        static readonly Singleton instance = new Singleton();

private Singleton() { }

        public static Singleton Instance
        {
            get
            {
                return instance;
            }
        }
    }
}

静态初始化，是在 .NET 中实现 Singleton 的首选方法。这段代码有点意思，我也解读一下。主要是讲解下关键字吧。

sealed:修改类，意为这个类不可再被继承，防止子类被实例化而不能保证只有一个实例的问题。

private Singleton():用private 修改构造函数，可以防止这个类在外部被实例。也就是在Singleton类外面想new Singleton()是会报编译错误。

static readonly:表示只能在声明时赋值，或是在静态构造中赋值。

第五种：延迟初始化

代码如下

复制代码

namespace Singleton
{
    class Program
    {
        static void Main(string[] args)
        {
            Singleton s1 = Singleton.Instance;
            Singleton s2 = Singleton.Instance;

            if (s1 == s2)
            {
                Console.WriteLine("Objects are the same instance");
            }

            Console.Read();
        }
    }

    public sealed class Singleton
    {
        public Singleton() { }

        public static Singleton Instance
        {
            get
            {
                return Delay.DelayInstance;
            }
        }
    }

    public sealed class Delay
    {
        private static readonly Singleton delayInstance = new Singleton();
        private Delay() { }

        public static Singleton DelayInstance
        {
            get
            {
                return delayInstance;
            }
        }
    }
}

把实例化的工作交给Delay类开实现，这样Singleton类就实现了延迟初始化。这种方式具有很多的优势，是值得推荐的一种实现方式。但是这种方式就需要开发人员记住不能使用new关键字实例化Singleton。

应用场景

其实不管是对于哪个设计模式来说，我们总会想知道什么时候能用到它。毕竟东西不是白学的，是猫是狗总也得带出来溜溜。

毕竟我也使用得少，所以这里面为了让网友能够看得大而全点，我摘自博友的内容如下：

1. Windows的Task Manager（任务管理器）就是很典型的单例模式（这个很熟悉吧），想想看，是不是呢，你能打开两个windows task manager吗？不信你自己试试看哦~

2. windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。

3. 网站的计数器，一般也是采用单例模式实现，否则难以同步。

4. 应用程序的日志应用，一般都可用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。

5. Web应用的配置对象的读取，一般也应用单例模式，这个是由于配置文件是共享的资源。

6. 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，因为使用单例模式来维护，就可以大大降低这种损耗。

7. 多线程的线程池的设计一般也是采用单例模式，这是由于线程池要方便对池中的线程进行控制。

8. 操作系统的文件系统，也是单例模式实现的具体例子，一个操作系统只能有一个文件系统。