C#单例模式

概述：

       单例模式是结构最简单的设计模式，它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以确保系统中的一个类只有一个实例，而且该实例易被外接访问，从而方便对实例个数进行控制，节约系统资源。

问题：

        如何保证一个类只有一个实例并且这个实例易于被访问呢？

        定义一个统一的全局变量可以确保对象谁是都可以被访问，但不能防止创建多个对象。这时候就需要单例模式的应用了

定义：

 确保一个类只有一个实例，并提供一个全局访问点来访问这个唯一的实例。

单例模式是一种对象创建型模式，有3个要点：

1、某个类只能有一个实例

2、它必须自行创建这个实例

3、它必须自行向整个系统提供这个实例

实现：

        单例模式只包含一个类，即单例类。

        单例模式只包含一个单例角色——Singleton（单例），在单例类的内部创建它的唯一实例，通过静态方法GetInstance()让客户段可以使用它的唯一实例。为了防止在外部对单例类的实例化，将其构造函数的可见性设为Private，并在单例类内部定义了一个Singleton类型的静态对象，作为供外部共享访问的唯一实例。

代码如下：

  class Singleton
    {
        private static Singleton instance = null;//静态私有成员变量
        //私有构造函数
        private Singleton()
        {

        }
        //静态共有工厂方法，返回唯一实例
        public static Singleton GeInstance()
        {
            if (instance==null)
            {
                instance = new Singleton();
            }
            return instance;
        }
    }

为了测试单例类所创建的对象的唯一性，可以编写以下客户端测试代码

        static void Main(string[] args)
        {
            Singleton s1 = Singleton.GeInstance();
            Singleton S2 = Singleton.GeInstance();
            if (s1==S2)
            {
                Console.WriteLine("两者是相同实例");
            }
            Console.ReadLine();
        }

结果显示：

两者是相同实例

饿汉式单例（Eager Singleton)

        这是实现起来最简单的单例类，由于在定义静态变量的时候实例化了单例类，因此在类加载时单例对象就已创建，代码如下：

  class EagerSingleton
    {
        private static EagerSingleton instance = new EagerSingleton();
        private EagerSingleton() { }
        public static EagerSingleton GetInstance()
        {
            return instance;
        }
    }

        当类被加载时，静态变量instance会被初始化，此时类的私有构造函数会被调用，单例类的唯一实例将被创建。

懒汉式单例类双重检查锁定（LazySingleton)

        与饿汉式单例类不同的是，懒汉式单例类在第一次被引用时自己实例化，在懒汉式单例类被加载时不会将自己实例化。而是在第一次调用静态工厂方法时实例化单例类，同时使用双重检查方式来避免多线程同时调用的情况

代码如下：

    class LazySingleton
    {
        private static LazySingleton instance = null;
        //程序运行时创建一个静态只读的辅助对象
        private static readonly object syncRoot=new object();
        private LazySingleton() { }
        public static LazySingleton GetInstance()
        {
            //第一重判断，先判断实例是否存在，不存在再加锁处理
            if (instance ==null )
            {
                //加锁的程序在某一时刻只允许一个线程访问
                lock (syncRoot)
                {
                    //第二重判断
                    if (instance==null )
                    {
                        instance = new LazySingleton();//创建单例实例
                    }
                }
            }
            return instance;
        }
    }

        以上为了避免在高并发，多线程环境下实现懒汉式单例类，某一时刻可能会有多个线程需要使用单例对象，即会有多个线程同时调用GetInstance()方法，可能会造成创建多个实例对象。所以需要使用lock关键字来进行锁定代码片段，实现同一时间只允许一个线程访问。

饿汉式单例类与懒汉式单例类比较

       饿汉式时典型的空间换时间，当类装载的时候就会创建类实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断了，节省了运行时间。

       懒汉式是典型的时间换空间，也就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。当然，如果一直没有人使用的话，就不会创建实例，则节约内存空间。