（一）单例模式详解

　　模式是一个非常有趣的话题，它是对特定前提下重复出现问题的一个普遍解答，它是一种思想，使用得当也会对设计、实施提供帮助。
　　简单的说，软件开发发展了几十年，前人遇到了很多很多的问题，有些人做了归纳总结，把某一类问题总结出一个解决套路，这些套路可以有效的解决类似的问题。形成了我们的23种模式。

概述
　　Singleton模式要求一个类有且仅有一个实例，并且提供了一个全局的访问点[DP]。
　　单例模式（Singleton）结构图

多线程时的单例
　　Lock是确保当一个线程位于代码的临界区时，另一个线程不进入临界区。如果其他线程试图进入锁定的代码，则它一直将等待（即被阻止），直到该对象被释放。[MSDN]

五种实现

(一)简单实现

• 简单实现很容易理解，只有在实例为空的情况下才创建新的实例。
• 但若处在多线程情况下，会出现问题：

1. 线程一执行完if(instance==null)这句后，准备进入下一句创建实例时，被挂起；
2. 此时切换到线程二，线程二全部执行完毕后，实例已经创建完毕。
3. 线程一激活，继续创建实例，造成双实例情况。违背单间原则。

代码如下：

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

namespace SingletonPattern
{
    /// <summary>
    /// <para>单例模式：简单实现</para>
    /// </summary>
    public sealed class Singleton
    {
        //静态构造函数
        static Singleton() { }

        //私有变量
        private static Singleton instance = null;

        //共有属性
        public static Singleton Instance
        {
            get
            {
                if (null == instance)
                {
                    instance = new Singleton();
                }
                return instance;
            }
        }
    }
}

安全的线程
　　此设计更正了简单实现出现的情况，其不会出现双线程时创建多个实例。
　　但是，进入Instance的Get方法后，直接被锁住，直到return结束后，才会允许其他线程进入。此处大大的降低了效率，因为其不管Instance是否为空，都加锁，有点不合适。

代码如下：

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

namespace SingletonPattern
{
    /// <summary>
    /// <para>单例模式：安全线程</para>
    /// </summary>
    public sealed class SecurityThreadSingleton
    {
        //静态构造函数
        static SecurityThreadSingleton() { }

        //用户加锁
        static readonly object padlock = new object();

        //私有变量
        private static SecurityThreadSingleton instance = null;

        //共有属性
        public static SecurityThreadSingleton Instance
        {
            get
            {
                //锁定
                lock (padlock)
                {
                    if (null == instance)
                    {
                        instance = new SecurityThreadSingleton();
                    }
                }
                return instance;
            }
        }
    }
}

双重锁定

• 双重锁定改善了安全的线程出现的性能降低的问题。如若Instance不为空，则不需要进入锁，提高了效率。
• 有人会问为什么锁外面判断一次实例是否为空，锁里面还有一次判断？

主要是考虑多线程，一个线程判断实例为空，进入锁时被挂起，切换到线程二，线程二恰好创建了实例，线程一继续执行时加上这层判断非常必要。

代码如下：

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

namespace SingletonPattern
{
    /// <summary>
    /// <para>单例模式：双重锁定</para>
    /// </summary>
    public class DoubleLockSingleton
    {
        //静态构造函数
        static DoubleLockSingleton() { }

        //用户加锁
        private static readonly object padlock = new object();

        //私有变量
        private static DoubleLockSingleton instance = null;

        //共有属性
        public static DoubleLockSingleton Instance
        {
            get
            {
                if (null == instance)
                {
                    //锁定
                    lock (padlock)
                    {
                        if (null == instance)
                        {
                            instance = new DoubleLockSingleton();
                        }
                    }
                }
                return instance;
            }
        }
    }
}

静态初始化
　　静态只读字段instance会在类被访问的时候被实例化，所以这点就与按需创建的原则相违背。
　　不过如若当前你的机器性能非常好，不在乎一个引用实例占用内存的情况，这点也就不用在乎。但是如若当前机器性能一般，需要计算内存的使用，建议使用下一种方法。

代码如下：

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

namespace SingletonPattern
{
    /// <summary>
    /// <para>单例模式：静态初始化</para>
    /// </summary>
    public sealed class StaticInitSingleton
    {
        //静态构造函数
        static StaticInitSingleton() { }

        //私有构造函数
        private StaticInitSingleton() { }

        //私有静态只读属性
        private static readonly StaticInitSingleton instance = new StaticInitSingleton();

        //
        public static StaticInitSingleton Instance
        {
            get { return instance; }
        }
    }
}

延迟初始化
　　此方法改善了静态初始化中的问题，实例按需创建。即在访问Instance时构造了instance实例。

代码如下：

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

namespace SingletonPattern
{
    /// <summary>
    /// <para>单例模式：延迟初始化</para>
    /// </summary>
    public sealed class LazyLoadingSingleton
    {
        //私有构造函数
        private LazyLoadingSingleton() { }

        //需要的时候加载
        public static LazyLoadingSingleton Instance
        {
            get { return Nested.instance; }
        }

        //内部类
        class Nested
        {
            static Nested() { }

            internal static readonly LazyLoadingSingleton instance = new LazyLoadingSingleton();
        }
    }
}

单例模式与静态类的区别

• 模式仅仅是一种思想，我们可以把静态类看成单件的一种实现，但是要了解，单件是控制实例的，而静态类是没有实例的。
• 静态类并不能够实现接口或继承，而我们所说的单件模式中的类是可以的，当然，我们不建议单件模式的类去继承派生，因为这样可能造成实例的不单一，但这恰恰标明单件模式的类与我们普通的类有相同属性，更能相通，灵活控制（可发展为双件模式或多件模式），而静态类与我们普通的类不同，没有如此的扩展性。
• 单件对象可以灵活维护自身对象的实例化，灵活性更大
• 一个项目中过多的使用静态类会造成环境污染，不好管理以及性能降低。

单例模式注意点
　　不要实现Icloneable接口或继承自其相关的子类，否则客户程序可以跳过已经隐蔽起来的类构造函数。下面的示例说明通过Icloneable接口的克隆过程导致私有构造函数失效，CLR通过内存结构的复制生成了一个新的实例，最终导致并非单一实例存在。
例：

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

namespace SingletonPattern
{
    public class BaseEntity : System.ICloneable
    {
        public object Clone()
        {
            return this.MemberwiseClone();
        }

    }
    public class Singleton : BaseEntity
    {
        //… ….
    }
}

　　严防序列化。对于远程访问，往往需要把复杂的对象序列化后进行传递，但是序列化本身会导致Singleton特性的破坏，因为序列化事实上完成了Singleton对象的拷贝。所以不能对期望具有Singleton特性的类型声明SerializableAttribute属性。

例：

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

using System.Runtime.Serialization.Formatters.Binary;

namespace SingletonPattern
{
    [Serializable]
    public class SerializableSingleton
    {
        //序列化
        public static string SerializeToString(SerializableSingleton graph)
        {
            MemoryStream memoryStream = new MemoryStream();

            BinaryFormatter sf = new BinaryFormatter();
            sf.Serialize(memoryStream, graph);

            Byte[] arrGraph = memoryStream.ToArray();

            return Convert.ToBase64String(arrGraph);
        }

        //反序列化
        public static SerializableSingleton DeserializeFromString(string serializedGraph)
        {
            Byte[] arrGraph = Convert.FromBase64String(serializedGraph);

            MemoryStream memoryStream = new MemoryStream(arrGraph);

            BinaryFormatter sf = new BinaryFormatter();
            SerializableSingleton obj = (SerializableSingleton)sf.Deserialize(memoryStream);

            return obj;
        }
    }
}

完整示例
　　这是一个简单的计数器例子，四个线程同时进行计数。

例：

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

using System.Threading;

namespace SingletonPattern
{
    public class CountSigleton
    {
        private CountSigleton()
        {
            Thread.Sleep(2000);
        }

        private int toNum = 0;

        static CountSigleton uniCounter = new CountSigleton();

        public static CountSigleton UniCounter
        {
            get { return CountSigleton.uniCounter; }
        }

        public void Add()
        {
            toNum++;
        }

        public int GetCounter()
        {
            return toNum;
        }
    }
}

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

namespace SingletonPattern
{
    public class CountMutilThread
    {
        public CountMutilThread() { }

        public static void DoSomeWork()
        {
            string results = "";
            CountSigleton MyCounter = CountSigleton.UniCounter;

            for (int i = 0; i < 5; i++)
            {
                MyCounter.Add();
                results += "线程";
                results += Thread.CurrentThread.Name.ToString() + "——〉";
                results += "当前的计数：";
                results += MyCounter.GetCounter().ToString();
                results += "
";

                Console.WriteLine(results);
                results = "";
            }
        }

        public void StartMain()
        {
            Thread thread0 = Thread.CurrentThread;
            thread0.Name = "Thread0";

            Thread thread1 = new Thread(new ThreadStart(DoSomeWork));
            thread1.Name = "Thread1";

            Thread thread2 = new Thread(new ThreadStart(DoSomeWork));
            thread2.Name = "thread2";

            Thread thread3 = new Thread(new ThreadStart(DoSomeWork));
            thread3.Name = "thread3";

            thread1.Start();

            thread2.Start();

            thread3.Start();

            /**/
            ///线程0也只执行和其他线程相同的工作
            DoSomeWork();
        }
    }
}

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

namespace SingletonPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            CountMutilThread cmt = new CountMutilThread();
            cmt.StartMain();
            Console.ReadLine();
        }
    }
}