单例模式

借鉴 小宝马的爸爸 单例模式讲解进行自我理解，（有关懒汉模式和饿汉模式见原文链接）

单例模式：单例模式的作用是保证在整个应用程序的生命周期中的任何一个时刻，单例类的实例最多只存在一次（可以不存在）。

单例模式的结构：（文字描述）

单例模式中有一个“私有化的”构造函数；

单例模式中有一个公开的public方法；

单例模式的定义：单例模式保证一个类仅有一个实例，同时这个类需要提供一个访问该类的全局访问点。即上面说的公开的public方法。

单例模式的代码结构：

/// <summary>
        /// 单例模式类
        /// </summary>
        public class danli()
        {
            /// <summary>
            /// 单例模式的构造函数*注意*private
            /// 因为构造函数是是有的，这样外部就无法使用new来创建该类的实例
            /// </summary>
            private danli(){
            
            }
            //定义一个私有化的静态全局变量来保存该类的唯一的实例
            private static danli dl;

            //定义一个只读的静态对象_ol
            //这个对象是在程序运行时候创建的
            private static readonly object _ol=new object();

            /// <summary>
            /// 定义一个全局的访问点，设置为静态方法
            /// 这样类的外部就无需实例化就可以调用该方法
            /// </summary>
            /// <returns></returns>
            public static danli getFangWen()
            {
                //这里可以保证只实例化一次
                //即在第一次调用时候实例化
                //以后调用不会再实例化

                //注意这里的第一次if(dl==null)
                if(dl==null)
                {
                    lock (_ol)
                    {
                        //这里的第二次if(dl==null)
                        if(dl==null)
                        {
                            dl=new danli();
                        }
                    }
                }
                return dl;

            }


        }

上面的就是改进后的代码，可以看到在类中有定义了一个静态的只读对象 _ol，

这里需要说明的是，为何还要创建一个 _ol 静态只读对象呢？

由于提供给 lock 关键字的参数必须为基于引用类型的对象，该对象用来定义锁的范围，

所以这个引用类型的对象总不能为 null 吧，而一开始的时候，_ol 为 null ，所以是无法实现加锁的，

所以必须要再创建一个对象即 _ol 来定义加锁的范围。

为什么代码中写了两次if(dl==null)?这样写有什么作用？

考虑这样一种情况，就是有两个线程同时到达，即同时调用 getFangWen();

此时由于 dl == null ，所以很明显，两个线程都可以通过第一重的 dl == null ，

进入第一重 if 语句后，由于存在锁机制，所以会有一个线程进入 lock 语句并进入第二重 dl == null ，

而另外的一个线程则会在 lock 语句的外面等待。

而当第一个线程执行完 new  danli（）语句后，便会退出锁定区域，此时，第二个线程便可以进入 lock 语句块，

此时，如果没有第二重 dl == null 的话，那么第二个线程还是可以调用 new  danli（）语句，

这样第二个线程也会创建一个 dl 实例，这样也还是违背了单例模式的初衷的，

所以这里必须要使用双重检查锁定。

细心的朋友一定会发现，如果我去掉第一重 dl == null ，程序还是可以在多线程下完好的运行的，

考虑在没有第一重 dl== null 的情况下，

当有两个线程同时到达，此时，由于 lock 机制的存在，第一个线程会进入 lock 语句块，并且可以顺利执行 new danli（），

当第一个线程退出 lock 语句块时， dl 这个静态变量已不为 null 了，所以当第二个线程进入 lock 时，

还是会被第二重 dl == null 挡在外面，而无法执行 new danli（），

所以在没有第一重 dl == null 的情况下，也是可以实现单例模式的？那么为什么需要第一重 dl == null 呢？

这里就涉及一个性能问题了，因为对于单例模式的话，new danli（）只需要执行一次就 OK 了，

而如果没有第一重 dl == null 的话，每一次有线程进入 getFangWen()时，均会执行锁定操作来实现线程同步，

这是非常耗费性能的，而如果我加上第一重 dl == null 的话，

那么就只有在第一次，也就是 dl ==null 成立时的情况下执行一次锁定以实现线程同步，

而以后的话，便只要直接返回 danli实例就 OK 了而根本无需再进入 lock 语句块了，这样就可以解决由线程同步带来的性能问题了。

好，到这里，就真正的把单例模式介绍完了，在此呢再总结一下单例类需要注意的几点：

一、单例模式是用来实现在整个程序中只有一个实例的。

二、单例类的构造函数必须为私有，同时单例类必须提供一个全局访问点。

三、单例模式在多线程下的同步问题和性能问题的解决。

四、懒汉式和饿汉式单例类。

五、C# 中使用静态初始化实现饿汉式单例类。