单例模式[Singleton]

单例模式也是一种简单得不要不要的设计模式，但实用性还是很强滴。

顾名思义，单例，就是设计一种模式，让类只能有一个实例。这种需求满街可见。就看windows系统，回收站、任务管理器，就是典型的单例。用户无论怎么操作，都不可能出现两个回收站或任务管理器的。

知道其意义后，就开始设计吧，第一个模型

using System;

namespace Singleton
{
    class Program
    {
        static void Main(string[] args)
        {
            LadyGaGa MyGirl = LadyGaGa.GetLadyGaGa();
            MyGirl.Dance();
            MyGirl.Sing();
        }

        public class LadyGaGa
        {
            /// <summary>
            /// 构造函数的访问级别被定义成了私有，这样外部就没办法直接new出来啦
            /// </summary>
            private LadyGaGa() { }

            private static LadyGaGa ImTheOne;

            /// <summary>
            /// 这里再提供一个访问ladygaga的方法
            /// </summary>
            /// <returns></returns>
            public static LadyGaGa GetLadyGaGa()
            {
                Console.Write("您成功邀请了Ladygaga参与你的party。当然，这个世界上如果特立独行的ladygaga只有一个");
                if (ImTheOne==null)
                {
                    Console.WriteLine("哟西。ladyGaGa还没出生");
                    ImTheOne = new LadyGaGa();
                }
                return ImTheOne;
            }
            public void Sing()
            {
                Console.WriteLine("Can't read my. Can't read my. No he can't read my poker face");
            }
            public void Dance()
            {
                Console.WriteLine("Ladgaga的舞蹈不是那么容易看到的。so hot");
            }
        }
    }
}

想法的核心，就是不让外部直接实例化Ladygaga。只是针对C#，要知道构造函数是可以私有的。

就到这里，已经深得单例模式的精髓，但前面的做法。是没考虑到多线程访问的时候，这个写法不是很安全就在

                if (ImTheOne==null)
                {
                    Console.WriteLine("哟西。ladyGaGa还没出生");
                    ImTheOne = new LadyGaGa();
                }

这段代码上，如果两个线程，同一时间访问，两家判断到的结果都是null，然后两家都new一个，这时候的世界就不美妙了。因此版本二开始。

            public static LadyGaGa GetLadyGaGa()
            {
                Console.Write("您成功邀请了Ladygaga参与你的party。当然，这个世界上如果特立独行的ladygaga只有一个");
                lock (LockerObject)
                {
                    if (ImTheOne == null)
                    {
                        Console.WriteLine("哟西，在这个有锁的世界里，我非常确定ladyGaGa还没出生，new 一个出来吧");
                        ImTheOne = new LadyGaGa();
                    }

                }
                return ImTheOne;
            }

无非就是加个锁。让这个单例做得更安全。有性能要求或处女座程序猿的情况，会想到每次访问GetLadyGaGa都要加锁，不太爽，就能再优化下。第三版

            public static LadyGaGa GetLadyGaGa()
            {
                Console.Write("您成功邀请了Ladygaga参与你的party。当然，这个世界上如果特立独行的ladygaga只有一个");

                if (ImTheOne == null)
                {
                    lock (LockerObject)
                    {
                        if (ImTheOne == null)
                        {
                            Console.WriteLine("哟西，在这个有锁的世界里，我非常确定ladyGaGa还没出生，new 一个出来吧");
                            ImTheOne = new LadyGaGa();
                        }
                    }

                }
                return ImTheOne;
            }

这里的改动跟单例设计模式关系不大了，只不过想到

if (ImTheOne == null)被执行的概率很低，先不加锁判断下，非null就直接返回了嘛。

来一恶心的分介线---------------------------------------

单例模式还有什么要理解的？还真有：根据这个实例的实例发时间段，可分为饿汉，懒汉两种方式，专业的叫法是饿汉，懒汉。
饿汉：一开始就要准备好实例，其实叫贪婪方式更易懂。
懒汉：没召唤都不会有实例，对应就叫懒惰方式罗。
懒惰方式，上面coding就是一个典型的栗子，有人邀请ladgaga时，才会全世界地找ladygaga是否在人世。
贪婪方式就得好好利用static了。

        public class LadyGaGa
        {
            /// <summary>
            /// 构造函数的访问级别被定义成了私有，这样外部就没办法直接new出来啦
            /// </summary>
            private LadyGaGa() { }

            private static LadyGaGa ImTheOne=new LadyGaGa();

            /// <summary>
            /// 这里再提供一个访问ladygaga的方法
            /// </summary>
            /// <returns></returns>
            public static LadyGaGa GetLadyGaGa()
            {                
                return ImTheOne;
            }
            public void Sing()
            {
                Console.WriteLine("Can't read my. Can't read my. No he can't read my poker face");
            }
            public void Dance()
            {
                Console.WriteLine("Ladgaga的舞蹈不是那么容易看到的。so hot");
            }
        }

比起懒惰方式，贪婪模式写得真是简单粗暴。

个人就觉得，单例的用途上，跟一个static实例本身功能一至，但有时还真是得用单例，才能用上对象的特性，如继承。

而贪、懒方式上，要根据具体情况来选择，如对象本身实例化很漫长很庞大，应用启用又没有时效要求，就应该用贪婪方式啦。