C# 单例设计模式学习记录

单例模式：把对象的创建权限关闭，提供一个公开的静态方法，起到对象重用

意义：

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

适用于：

数据临时存储的地方静态字典/数据库连接池/线程池/IOC的容器实例/配置文件信息保存

 

单例模式：保证进程当中，某个类只有一个实例

问题是怎样保证？怎么样强制保证呢？

单例就是为了只有一个实例，比如数据临时存储的地方静态字典/数据库连接池/线程池/IOC的容器实例/配置文件信息保存。 而不是用来解决线程冲突的。

 

单例模式和普通实例的区别：

单例模式会长期持有一个对象，不会释放。而普通实例在使用完后就会进行释放。

单例模式只会进行一次构造，如果你的构造函数非常消耗性能，那么你使用单例就会提升你的性能。

个人推荐大家先去学习一下设计模式六大原则，因为所有的设计模式归根到底都是根据六大原则进行的具体化。

 

懒汉式单例模式实现：

    /// <summary>
    /// 懒汉式单例模式
    /// </summary>
    public class Singleton//<T> //泛型类型里面的静态字段，是随着不同的类型参数唯一的  泛型单例不可能的
    {
        /// <summary>
        /// 构造函数耗时耗资源
        /// </summary>
        private Singleton()//1 private  避免外部创建
        {
            long lResult = 0;
            for (int i = 0; i < 10000000; i++)
            {
                lResult += i;
            }
            Thread.Sleep(1000);
            Console.WriteLine("{0}被构造一次", this.GetType().Name);
        }

        /// <summary>
        /// 3 全局唯一静态  重用这个变量
        /// </summary>
        private static volatile Singleton _Singleton = null;//volatile 促进线程安全 让线程按顺序操作
        private static object Singleton_Lock = new object();

        /// <summary>
        /// 2 公开的静态方法提供对象实例
        /// </summary>
        /// <returns></returns>
        public static Singleton CreateInstance()
        {
            if (_Singleton == null)//假如现在 5个线程过来初始化  第1个线程进去把_Singleton实例化；5分钟之后，又有100个线程同时来创建，  排队--判断不为空--然后返回   其实不该排队了，应该直接判断
            {
                lock (Singleton_Lock)//保证只有一个线程进去判断+初始化
                {
                    if (_Singleton == null)//这个也不能去掉，第一次5个线程进来的时候  如果没有这个判断，还是重复创建的
                    {
                        _Singleton = new Singleton();
                    }
                }
            }
            return _Singleton;
        }//懒汉式  调用了方法才去构造




        //既然是单例，大家用的是同一个对象，用的是同一个方法，那还会并发吗  还有线程安全问题吗？
        //当然有，，单例不能解决线程冲突的  解决：加锁

        public int iTotal = 0;
        public void Show()
        {
            //lock
            this.iTotal++;
        }

        public static void Test()
        { }

    }

 

 饿汉式单例模式实现：

   /// <summary>
    /// 饿汉式：特点就是 只要使用了类就会被构造
    /// </summary>
    public class SingletonSecond //<T>  泛型类型里面的静态字段，是随着不同的类型参数唯一的，所以泛型单例是不可能也没用实际意义的
    {
        /// <summary>
        /// 私有化  防止外部调用
        /// </summary>
        private SingletonSecond() {

        }

        /// <summary>
        /// 全局唯一静态 ， 单例 
        /// </summary>
        private static volatile SingletonSecond _SingletonSecond = null; //volatile 促进线程安全，让线程按顺序操作

        /// <summary>
        /// 静态构造函数：利用CLR保证，程序第一次使用这个类型前被调用，并且只被调用一次
        /// 
        /// 写日志功能的文件夹检测
        /// xml配置文件
        /// </summary>
        static SingletonSecond() {
            _SingletonSecond = new SingletonSecond();
            Console.WriteLine("SingletonSecond 被构造了");
        }

        /// <summary>
        ///  外部创建实例的唯一途径
        /// </summary>
        /// <returns>实例</returns>
        public static SingletonSecond CreateInstance() {
            return _SingletonSecond;
        }

    }