单例模式

设计模式最终目的：
通过封装，继承，多态把程序的耦合降低，增加程序的复用性，可维护性，灵活性，扩展性，减少重复代码等等，把面向过程的开发方式转为面向对象，面向抽象，面向接口的开发方式。

有关设计模式的三大分类及六大原则详细介绍
代码链接

概述：
单例（Singleton）模式要求一个类有且仅有一个实例，并且提供了一个全局的访问点。这就提出了一个问题：如何绕过常规的构造器，提供一种机制来保证一个类只有一个实例？客户程序在调用某一个类时，它是不会考虑这个类是否只能有一个实例等问题的，所以，这应该是类设计者的责任，而不是类使用者的责任。 从另一个角度来说，Singleton模式其实也是一种职责型模式。因为我们创建了一个对象，这个对象扮演了独一无二的角色，在这个单独的对象实例中，它集中了它所属类的所有权力，同时它也肩负了行使这种权力的职责！

核心作用：
保证一个类只有一个实例，并且提供一个访问该实例的全局访问点

优点：
1.在单例模式中，活动的单例只有一个实例，对单例类的所有实例化得到的都是相同的一个实例。这样就 防止其它对象对自己的实例化，确保所有的对象都访问一个实例
2.单例模式具有一定的伸缩性，类自己来控制实例化进程，类就在改变实例化进程上有相应的伸缩性。
3.提供了对唯一实例的受控访问。
4.由于在系统内存中只存在一个对象，因此可以 节约系统资源，当 需要频繁创建和销毁的对象时单例模式无疑可以提高系统的性能。
5.允许可变数目的实例。
6.避免对共享资源的多重占用。

缺点：
1.不适用于变化的对象，如果同一类型的对象总是要在不同的用例场景发生变化，单例就会引起数据的错误，不能保存彼此的状态。
2.由于单利模式中没有抽象层，因此单例类的扩展有很大的困难。
3.单例类的职责过重，在一定程度上违背了“单一职责原则”。
4.滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。

注意事项：
1.使用时不能用反射模式创建单例，否则会实例化一个新的对象
2.单例模式在多线程的 应用场合下必须小心使用。如果当唯一实例尚未创建时，有两个线程同时调用创建方法，那么它们同时没有检测到唯一实例的存在，从而同时各自创建了一个实例， 这样就有两个实例被构造出来，从而违反了单例模式中实例唯一的原则。 解决这个问题的办法是为指示类是否已经实例化的变量提供一个互斥锁(虽然这样会降低效率)。

适用场景：
1.需要频繁实例化然后销毁的对象。
2.创建对象时耗时过多或者耗资源过多，但又经常用到的对象。
3.有状态的工具类对象。
4.频繁访问数据库或文件的对象。

标准的单例模式：

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

namespace SingletonPattern
{
    /// <summary>
    /// 私有化构造函数
    /// 私有的静态变量
    /// 提供一个访问该实例的全局访问点（静态的对象创建方法）
    /// 目的：让使用者无法通过构造函数创建对象；只能通过设计者提供的静态的对象创建方法返回的私有的自身类型静态变量（单例对象）
    /// </summary>
    public class Singleton
    {
        private Singleton()
        {
            Thread.Sleep(1000);//耗时
            //string bigSize = "占用10M内存";//耗计算资源
            //string resource = "占用多个线程和数据库连接资源";//耗有限资源
            Console.WriteLine("{0}被构造，线程id={1}", this.GetType().Name, Thread.CurrentThread.ManagedThreadId);
        }

        private static Singleton _Singleton = null;
        private static readonly object Singleton_Lock = new object();

        public static Singleton CreateInstance()
        {
            if (_Singleton == null)//保证对象初始化之后的所有线程，不需要等待锁
            {
                Console.WriteLine("准备进入lock");
                lock (Singleton_Lock)//保证只有一个线程进去判断
                {
                    //Thread.Sleep(1000);
                    if (_Singleton == null)//保证对象为空才真的创建
                    {
                        _Singleton = new Singleton();
                    }
                }
            }
            return _Singleton;
        }

        public void Show()
        {
            Console.WriteLine("这里调用了{0}.Show", this.GetType().Name);
        }

    }
}

利用静态构造函数来实现单例

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

namespace SingletonPattern
{
    /// <summary>
    /// 私有化构造函数
    /// 私有静态只读变量
    /// 静态构造函数（不能有访问修饰符）对私有静态只读变量创建对象：由CLR自行调用，在第一次使用这个类之前，调用而且只调用一次
    /// 提供一个访问该实例的全局访问点（单例对象获取的静态方法）
    /// 目的：让使用者无须也不能通过构造函数创建对象；只能通过设计者提供的单例对象获取的静态方法获取单例对象（返回私有的自身类型的静态变量对象）
    /// </summary>
    public class SingletonSecond
    {
        private SingletonSecond()
        {
            Thread.Sleep(1000);//耗时
            //string bigSize = "占用10M内存";//耗计算资源
            //string resource = "占用多个线程和数据库连接资源";//耗有限资源
            Console.WriteLine("{0}被构造，线程id={1}", this.GetType().Name, Thread.CurrentThread.ManagedThreadId);
        }

        private static readonly SingletonSecond _Singleton = null;

        /// <summary>
        /// 静态构造函数：由CLR自行调用，在第一次使用这个类之前，调用而且只调用一次
        /// </summary>
        static SingletonSecond()
        {
            _Singleton = new SingletonSecond();
        }
        public static SingletonSecond CreateInstance()
        {
            return _Singleton;
        }


        public void Show()
        {
            Console.WriteLine("这里调用了{0}.Show", this.GetType().Name);
        }
    }
}

在声明私有静态只读变量的同时直接初始化来实现单例

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

namespace SingletonPattern
{
    /// <summary>
    /// 私有化构造函数
    /// 私有静态只读变量；声明私有静态只读变量的同时直接初始化；初始化由CLR自行调用，在第一次使用这个类之前，调用而且只调用一次
    /// 提供一个访问该实例的全局访问点（单例对象获取的静态方法）
    /// 目的：让使用者无须也不能通过构造函数创建对象；只能通过设计者提供的单例对象获取的静态方法获取单例对象（返回私有的自身类型的静态变量对象）
    /// </summary>
    public class SingletonThird
    {
        private SingletonThird()
        {
            Thread.Sleep(1000);//耗时
            //string bigSize = "占用10M内存";//耗计算资源
            //string resource = "占用多个线程和数据库连接资源";//耗有限资源
            Console.WriteLine("{0}被构造，线程id={1}", this.GetType().Name, Thread.CurrentThread.ManagedThreadId);
        }

        private static readonly SingletonThird _Singleton = new SingletonThird();

        public static SingletonThird CreateInstance()
        {
            return _Singleton;
        }

        public void Show()
        {
            Console.WriteLine("这里调用了{0}.Show", this.GetType().Name);
        }
    }
}

测试：

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

namespace SingletonPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                List<IAsyncResult> resultList = new List<IAsyncResult>();
                for (int i = 0; i < 10; i++)
                {
                    resultList.Add(new Action(() =>
                    {
                        Singleton singleton = Singleton.CreateInstance();
                        singleton.Show();
                    }).BeginInvoke(null, null));//会启动一个异步多线程调用
                }

                while (resultList.Count(r => !r.IsCompleted) > 0)
                {
                    Thread.Sleep(10);
                }

                for (int i = 0; i < 10; i++)
                {
                    resultList.Add(new Action(() =>
                    {
                        //SingletonSecond singleton = SingletonSecond.CreateInstance();
                        SingletonThird singleton = SingletonThird.CreateInstance();
                        singleton.Show();
                    }).BeginInvoke(null, null));//会启动一个异步多线程调用
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            Console.Read();
        }
    }
}