单例模式（饿汉VS懒汉）

单例模式（Singleton），保证一个类仅有一个实例，并提供一个访问它的全局访问点。

“通常我们可以让一个全局变量使得一个对象被访问，但它不能防止你实例化多个对象，一个最好的办法就是，让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建，并且它可以提供一个访问该实例的方法。”

单例模式（Singleton）结构图：

Singleton类，定义一个GetInstance操作，允许客户访问它的唯一实例，GetInstance是一个静态方法，主要负责创建自己的唯一实例。

基本代码：

class Singleton
    {
        private static Singleton instance;

        //构造方法让其private，这就堵死了外界利用new创建此类实例的可能
        private Singleton()
        { }
        //此方法是获得本类实例的唯一全局访问点
        public static Singleton GetInstance()
        {
            //若实例不存在，则new一个新实例，否则返回已有的实例
            if (instance ==null )
            {
                instance = new Singleton(); 
            }
            return instance;
        }
    }

客户端代码：

static void Main(string[] args)
        {
            Singleton s1 = Singleton.GetInstance();
            Singleton s2 = Singleton.GetInstance();

            if (s1==s2 )
            {
                Console.WriteLine("两个对象是相同的实例。"); 
            }

            Console.Read();
        }

此外，单例模式因为Singleton类封装它的唯一实例，这样它可以严格地控制客户怎样访问它以及何时访问它。简单的说就是对唯一实例的受控访问。

改进：

这里先介绍一下线程：线程，是程序执行流的最小单元，是进程中的一个实体，是被系统独立调度和分派的基本单位。一个线程可以创建和撤销另一个线程，同一进程中的多个线程可以并发执行。

线程是程序中一个单一的顺序控制流程。进程内一个相对独立的、可调度的执行单元，是系统独立调度和分派CPU的基本单位指运行中的程序的调度单位。在单个程序中同时运行多个线程完成不同的工作，称为多线程。

现实中如果是在多线程的程序中，多个线程同时进行，意即同时访问Singleton类，调用GetInstance()方法，也是会有可能造成创建多个实例的。

解决方法：如果多个线程同时进行，此时可以给进程一把锁来处理，即引入lock语句来处理。lock是确保党一个线程位于代码的临界区时，另一个线程不进入临界区。如果其他线程试图进入锁定的代码，则它将一直等待（即被阻止），直到该对象将被释放。

基本代码：

//多线程时的单例
    class Singleton
    {
        private static Singleton instance;
        //程序运行时创建一个静态只读的进程辅助对象
        private static readonly object syncRoot = new object();
        private Singleton()
        {
        }

        //在同一个时刻加了锁的那部分程序只有一个线程可以进入
        public static Singleton GetInstance()
        {
            lock (syncRoot)
            {
                if (instance ==null )
                {
                    instance = new Singleton();  
                }
                
            }
            return instance;
        }
    }

此时就可以使得对象实例由最先进入的那个线程创建，以后的线程在进入时不会再去创建对象实例。有了lock，就保证了多线程环境下的同时访问也不会造成多个实例的生成。

但是每次要调用GetInstance方法时都需要lock，会影响产品的性能，此时引入了双重锁定（Double-Check Locking)

//双重锁定
    class Singleton
    {
        private static Singleton instance;
        private static readonly object syncRoot = new object();
        private Singleton()
        { 

        }
        public static Singleton GetInstance()
        {
            if (instance ==null )
            {
                lock (syncRoot)
                {
                    if (instance ==null )
                    {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }

    }

此时，不用让线程每次都加锁，而只是在实例未被创建时再加锁处理，同时确保多线程的安全。

实际编程环境中，C#与公共语言运行库也提供了一种‘静态初始化’的方法，这种方法不需要开发人员显式的编写线程安全代码，就可以解决多线程环境下它是不安全的问题。

public sealed class singleton
    {
        //在第一次引用类的任何成员时创建实例。公共语言运行库负责处理变量初始化
        private static readonly singleton instance = new singleton();
        private singleton() { }
        public static singleton GetInstance()
        {
            return instance;
        }
    }

这里的sealed方法是阻止发生派生，而派生可能会增加实例。

这种静态初始化的方法在自己被加载时就将自己实例化，所以被形象地称为饿汉式单例类；原先的单例模式在第一次被引用时，才会将自己实例化，所以称为懒汉式单例类。