简单的研究了一下单例模式

　　之前我喜欢只是单纯的记记笔记，没有什么写文章的习惯，今天也是我一边研究一边学习，索性就连过程什么的都记录下吧，或许能帮到一两个朋友呢。

　　首先，我们来想想什么叫做单例，顾名思义，单一的一个对象，那么，单一模式有什么好处呢？比如说，你的对象只可以实例化一次等等。

　　先写一个简单的测试里的例子吧，比如我建一个类，叫做TestSingle

　　

 /// <summary>
    /// 单例模式简单的例子（sealed，不可继承）
    /// </summary>
    public sealed class TestSingle
    {
    }

　　首先要让这个类不可继承，要不然就没有意义了，那么，接下来做什么呢？让一个对象只实例化一次，从而降低等等一些乱七八糟的东西。专业名词很多，百度搜搜就可以看到了。我们在实例化一个对象会做什么呢？肯定是new一个对象了，那么new对象的时候会发生什么事情呢？就是执行构造函数，那如何让我们这个类只实例化一次呢？看样子只能从构造函数入手了。

　　

 /// <summary>
        /// 用来记录构造函数执行的次数
        /// </summary>
        private static int structureCount = 0;

        /// <summary>
        /// 私有的无参构造函数
        /// </summary>
        private TestSingle() 
        {
            structureCount++;
            Console.WriteLine("只是第{0}次执行构造函数", structureCount);
        } 

　　首先我定义了一个静态的变量用来存储构造函数执行的次数，并在构造函数中输出执行的次数。当我把构造函数私有化之后，如何通过别的方式来让外界访问到呢？我们来写一个public的方法，来提供外界的调用，当然，这个方法也是一个静态的方法。

 /// <summary>
        /// 实例化时执行的此处
        /// </summary>
        private static int createStructureCount = 0;

        /// <summary>
        /// TestSingle
        /// </summary>
        private static TestSingle testSingle = null;


  /// <summary>
        /// 创建一个testSingle的实例
        /// </summary>
        /// <returns></returns>
        public static TestSingle CreateTestSingle()
        {
            createStructureCount++;
            Console.WriteLine("我是第{0}次创建TestSingle实例化", createStructureCount);
            testSingle = new TestSingle();
            return testSingle;
        }

　　这样写和一个普通的new又有什么区别？我们来把方法改造一下

 /// <summary>
        /// 创建一个testSingle的实例
        /// </summary>
        /// <returns></returns>
        public static TestSingle CreateTestSingle()
        {
            createStructureCount++;
            Console.WriteLine("我是第{0}次创建TestSingle实例化", createStructureCount);
            if (testSingle == null)
            {
                testSingle = new TestSingle();
            }
            return testSingle;
        }

　　我们去执行一下测试一下看效果如何。

　　我们可以看到构造函数被执行了两次，我电脑的CPU性能并不是很好，如果好一点的电脑可能会执行更多次。那么我是怎么进行测试的呢？我写了一个线程工厂，不停的去CreateTestSingle

 static void Main(string[] args)
        {
            //创建一个Task工厂
            TaskFactory taskFactory = new TaskFactory();
            for (int i = 0; i < 20; i++)
            {
                taskFactory.StartNew(() => TestSingle.CreateTestSingle());
            }
            Console.ReadLine();
        }

　　也就是说，在很多个线程同时去Create的时候，不妨还是new了多个对象。所以光这样是不行的，所以我加了一个锁和双层判断

　　

  /// <summary>
        /// 锁定对象
        /// </summary>
        private static object lock_SingleTest = new object();

  /// <summary>
        /// 创建一个testSingle的实例
        /// </summary>
        /// <returns></returns>
        public static TestSingle CreateTestSingle()
        {
            if (testSingle == null)
            {
                lock (lock_SingleTest)
                {
                    if (testSingle == null)
                    {
                        testSingle = new TestSingle();
                    }
                   
                }
            }
            createStructureCount++;
            Console.WriteLine("我是第{0}次创建TestSingle实例化", createStructureCount);
            return testSingle;
        }

　　再次执行一次

　　这样的话，不管我执行多少次，构造函数都始终只会被执行一次。大家可以让线程睡眠后再打印看看结果，那样我想你就可以看的出来效果了。哦了，这样我们就把单例模式创建完了。