单例模式

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

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

举例如下：

    /// <summary>
    /// 普通的单例模式
    /// 通过将构造函数私有化，并提供私有静态变量和静态方法达到对实例化的控制
    /// 这种方式生成的对象是在使用时才被实例化，因此被称为懒汉式
    /// </summary>
    class CommonSingleton
    {
        private static CommonSingleton instance;

        private CommonSingleton()
        { }

        public static CommonSingleton GetInstance()
        {
            if (instance == null)
            {
                instance = new CommonSingleton();
            }
            return instance;
        }
    }

　客户端调用：

            CommonSingleton commonSingleton1 = CommonSingleton.GetInstance();
            CommonSingleton commonSingleton2 = CommonSingleton.GetInstance();

            if (commonSingleton1==commonSingleton2)
            {
                Console.WriteLine("commonSingleton is the same one."); 
            }

运行结果为：　　commonSingleton is the same one.

在多线程的程序中，多个线程同时访问Singleton的GetInstance()放法，还是有可能造成创建多个实例，这是需要引入锁(lock)机制，lock是确保当一个线程位于代码的临界区时，另一个线程不进入临界区，如果其他线程试图进入锁定的代码，则它将一直等待，直到该对象被释放，举例如下：

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

        private LockSingleton()
        { }

        public static LockSingleton GetInstance()
        {
            
            lock (syncRoot)
            {
                //同一个时刻，这部分程序只有一个线程可以进入
                if (instance == null)
                {
                    instance = new LockSingleton();
                }
                return instance;
            }

        }
    }

这段代码使得对象的创建由最先进入的那个线程创建，以后的线程在进入时不会再创建对象实例了。

但是每次调用GetInstance方法时都需要Lock，即线程直线可能会被阻塞，这会影响性能，更好的办法是采用双重锁定，举例如下：

    /// <summary>
    /// Double-Check Locking
    /// 对锁定方法的改进，仅在实例为null时加锁，提高了代码的效率
    /// </summary>
    class DoubleCheckLockSingleton
    {
        private static DoubleCheckLockSingleton instance;
        private static readonly object syncRoot = new object();

        private DoubleCheckLockSingleton()
        { }

        public static DoubleCheckLockSingleton GetInstance()
        {
            //先判断实例是否存在，不存在再加锁处理
            if (instance == null)
            {
                lock (syncRoot)
                {
                    if (instance == null)
                    {
                        instance = new DoubleCheckLockSingleton();
                    }

                }
            }
            return instance;
        }
    }

　这样即提高了效率，又解决了多线程下的单例问题。

在C#中提供了一种“静态初始化”方法，这种方法不需要开发人员显示的编写线程安全代码，即可解决多线程环境下的不安全问题，举例如下：

    /// <summary>
    /// 静态初始化方法实现单例模式
    /// 使用sealed关键字避免类的继承，使用readonly使得变量只能在静态初始化期间或类构造函数中分配变量
    /// 私有的构造方法使得不能再类本身以外的地方实例化Singleton类
    /// 这种方法中的实例是在类被加载时就实例化，因此被称为饿汉模式
    /// </summary>
    sealed class Singleton
    {
        //第一次引用类的任何成员时创建实例，公共语言运行库负责处理变量的初始化
        private static readonly Singleton instance = new Singleton();

        private Singleton()
        { }

        public static Singleton GetInstance()
        {
            return instance;
        }
    }

　由于饿汉式即静态初始化方式是在类一加载就实例化对象，所以要提前占用系统资源，而懒汉式又需要双重锁定机制保证线程安全，所以采用哪种方式，取决于实际需要。从C#语言角度来讲，饿汉式的单例类已经能够满足我们的需求了。