我眼中的单例模式

时间 2019-11-08

标签眼中模式繁體版

原文原文链接

说到单例模式，网上搜索出来的结果是多如牛毛，但这不影响我也来凑热闹的心情。html

任何事情都是要亲身去体会了，才能加深本身的理解。本着不断学习进取的精神，我很想能够站在牛人的肩膀上，哪怕是仰视牛人的状况下，我也想发挥本身的余热。记录下本身学习的足迹，权当本身将来细细回味也好。（不过说真的，本身试着去组织语言来介绍你的问题也好，你的产品也好，能在很大的程度上提升你的表达能力。大脑是越锻炼越活的东西，讲话、写做也同样，锲而不舍，必有收获。总之，贵在坚持哦！）数据库

好了，我先声明下我参考的牛人文章出处：http://terrylee.cnblogs.com/archive/2005/12/09/293509.htmlwindows

下面来介绍模式，单例模式就是保证一个类仅有一个实例，并提供一个访问它的全局访问点。设计模式

其实就是实现只有一个门能够进入，且每次只给一我的进入。这就像之前的一位博友所举的例子，不少人排队去厕所蹲坑同样，每一次只能让一我的去蹲坑。实现单例模式的缘由，要么是资源共享，要么是控制资源等。所谓资源共享，就是由于单例模式保证了一个类仅有一个实例，因此你们访问的实例是一致的。而控制资源的话，主要是减小资源的申请与释放等。安全

牛人就是牛人，一下给出了五种实现单例模式的例子。看得我茅塞顿开，大呼过瘾。多线程

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

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. 操做系统的文件系统，也是单例模式实现的具体例子，一个操做系统只能有一个文件系统。

9. HttpApplication 也是单例模式的典型应用。熟悉ASP.Net(IIS)的整个请求生命周期的人应该知道HttpApplication也是单例模式，全部的HttpModule都共享一个HttpApplication实例。

固然若是你有新的使用场景，请不吝赐教:)

至此，本文完！