c#设计模式(1)——单例模式

一、引言

       最近看了一些单例模式的介绍，感觉可以总结一下，形成自己的笔记。部分内容选自https://www.cnblogs.com/zhili/p/SingletonPatterm.html,感觉写得很好，我只是再加点东西

二、介绍

      单例模式（Singleton Pattern）是最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

      这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

     注意：

          1、单例类只能有一个实例。

          2、单例类必须自己创建自己的唯一实例。

          3、单例类必须给所有其他对象提供这一实例。

三、多种单例模式的创建方式

    1.饿汉式创建单例模式

     说明：饿汉就是类一旦加载，就把单例初始化完成，保证CreateSingleton的时候，单例是已经存在的了。饿汉式创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成。

     

    /// <summary>
    /// 饿汉式写法
    /// </summary>
    public class SingletonEH
    {
        /**
         *是否 Lazy 初始化：否
         *是否多线程安全：是
         *实现难度：易
         *描述：这种方式比较常用，但容易产生垃圾对象。
         *优点：没有加锁，执行效率会提高。
         *缺点：类加载时就初始化，浪费内存。
         *它基于 classloder 机制避免了多线程的同步问题，
         * 不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，
         * 在单例模式中大多数都是调用 CreateSingleton 方法，
         * 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，
         * 这时候初始化 instance 显然没有达到 lazy loading 的效果。
        */
        private static SingletonEH instance = new SingletonEH();

        private SingletonEH()
        {
            Console.WriteLine($"{typeof(SingletonEH).Name}被构造。。。");
        }
        public static SingletonEH CreateSingleton()
        {
            return instance;
        }
    }

　　2.懒汉式创建单例模式

        说明：而懒汉比较懒，只有当调用CreateSingleton的时候，才回去初始化这个单例。懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要做初始化，如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了。

        

 /// <summary>
    /// 懒汉式
    /// </summary>
    public class SingletonLH
    {
        /**
     *是否 Lazy 初始化：否
     *是否多线程安全：是
     *实现难度：易
     *描述：这种方式比较常用，但容易产生垃圾对象。
     *优点：没有加锁，执行效率会提高。
     */
        private static SingletonLH instance = null;

        private SingletonLH()
        {
            Console.WriteLine($"{typeof(SingletonLH).Name}被构造。。。");
        }

        public static SingletonLH CreateInstance()
        {
            if(instance == null)
            {
                 return new SingletonLH();
             }
            return instance;
        }
    }

　　3.上面的单例模式的实现在单线程下确实是完美的,然而在多线程的情况下会得到多个Singleton实例,因为在两个线程同时运行CreateInstance方法时，此时两个线程判断(instance ==null)这个条件时都返回真，此时两个线程就都会创建Singleton的实例，这样就违背了我们单例模式初衷了，既然上面的实现会运行多个线程执行，那我们对于多线程的解决方案自然就是使CreateInstance方法在同一时间只运行一个线程运行就好了，也就是我们线程同步的问题了。

       

  public class SingletonLH
    {
        /**
     *是否 Lazy 初始化：否
     *是否多线程安全：是
     *实现难度：易
     *描述：这种方式比较常用，但容易产生垃圾对象。
     *优点：没有加锁，执行效率会提高。
     *缺点：类加载时就初始化，浪费内存。
     *它基于 classloder 机制避免了多线程的同步问题，
     * 不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，
    * 在单例模式中大多数都是调用 CreateInstance 方法，
     * 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，
     * 这时候初始化 instance 显然没有达到 lazy loading 的效果。
     */
        private static SingletonLH instance = null;

        private static readonly object locker = new object();
        private SingletonLH()
        {
            Console.WriteLine($"{typeof(SingletonLH).Name}被构造。。。");
        }

        public static SingletonLH CreateInstance()
        {
             lock (locker)
             {
                 if(instance == null)
                {
                     return new SingletonLH();
                 }
            }
            return instance;
        }
    }

　　上面代码对于每个线程都会对线程辅助对象locker加锁之后再判断实例是否存在，对于这个操作完全没有必要的，因为当第一个线程创建了该类的实例之后，后面的线程此时只需要直接判断（instance==null）为假，此时完全没必要对线程辅助对象加锁之后再去判断，所以上面的实现方式增加了额外的开销，损失了性能，为了改进上面实现方式的缺陷，我们只需要在lock语句前面加一句（instance==null）的判断就可以避免锁所增加的额外开销，这种实现方式我们就叫它 “双重锁定”，

  

  public class SingletonLH
    {
      
        private static SingletonLH instance = null;

        private static readonly object locker = new object();
        private SingletonLH()
        {
            Console.WriteLine($"{typeof(SingletonLH).Name}被构造。。。");
        }

        public static SingletonLH CreateInstance()
        {
            if(instance == null)
            {
                lock (locker)
                {
                    if(instance == null)
                    {
                        return new SingletonLH();
                    }
                }
            }
            return instance;
        }
    }

　　4. 泛型封装单例模式，利于重复利用

         a.新建一个类 BaseSingleton类

          

 public class BaseSingleton<T> where T: new()
    {
        protected static T _instance;
        private static readonly object locker = new object();

        public static T getInstance()
        {
            if(_instance == null)
            {
                lock (locker)
                {
                    if(_instance == null)
                    {
                        _instance = new T();
                    }
                }
            }
            return _instance;
        }
    }

　　b.需要用到的类继承调用

      

 public class Singleton: BaseSingleton<Singleton>
    {
        public int Id { get; set; }

        public string Name { get; set; }

        public static void Test()
        {
            Console.WriteLine("this is Test...");
        }
    }