单例模式

1.什么是单例模式？

　　单例模式就是保证进程中某一个类只有一个实例。

2.为什么要有单列模式？

　　1）构造对象需要耗时好资源 

　　2）一个对象可能会在多个地方存在 

　　3）想避免对象重复构造

3.怎么保证只有一个实例？

　　1）私有化构造函数，避免别人去实例化对象

　　2）在类里面提供一个公开的静态方法，在静态方法里面实例化对象

　　3）初始化一个公开的静态字段用于返回实例化的对象，保证全局只有一个对象

4.应对一些特殊情况：比如数据库连接池，全局唯一号码生成器

5.单例的两种模式

　　1）经典模式：就是我们经常说的双IF+锁（Lock）

　　　　

public class Singleton
    {
        private static Singleton _singleton = null;
        private static object _isLock = new object();

        public static Singleton CreateIntance()
        {
            //对象_singleton已经被初始化了就不要进入锁等待了
            if (_singleton == null)
            {
                //加锁，保证任意时刻只有一个线程进入lock范围
                lock (_isLock)
                {
                    Thread.Sleep(3000);
                    Console.WriteLine("等待锁2s之后在继续...");
                    //对象是否已经创建
                    if (_singleton == null)
                    {
                        _singleton = new Singleton();
                    }
                }
            }
            return _singleton;
        }
25     }

　　2）饥饿模式

　　

public class Hungry
    {
        private static Hungry _singleton = null;
        private static Hungry _singleton1 = new Hungry();
        /// <summary>
        /// 静态构造函数：由CLR保证，程序第一次使用这个类型前被调用一次，并且只调用一次
        /// 检测，初始化，
        /// 写日志功能的文件夹检测
        /// XML配置文件
        /// </summary>
        static Hungry()
        {
            _singleton = new Hungry();
            Console.WriteLine($"Hungry 被启用...");
        }

        /// <summary>
        /// 恶汉模式，只要使用这个类就会被调用
        /// </summary>
        /// <returns></returns>
        public static Hungry CreateIntance()
        {
            return _singleton;
        }

        /// <summary>
        /// 静态字段在第一次使用这个类之前，由CLR保证初始化并且只初始化一次（比构造函数还早）
        /// 恶汉模式，只要使用这个类就会被调用
        /// </summary>
        /// <returns></returns>
        public static Hungry CreateIntance1()
        {
            return _singleton1;
        }
    }