单例模式

1.什么是单例模式？

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

2.为何要有单列模式？

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

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

　　3）想避免对象重复构造

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

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

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

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

4.应对一些特殊状况：好比数据库链接池，全局惟一号码生成器

5.单例的两种模式

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

　　　　

 1 public class Singleton
 2     {
 3         private static Singleton _singleton = null;
 4         private static object _isLock = new object();
 5 
 6         public static Singleton CreateIntance()
 7         {
 8             //对象_singleton已经被初始化了就不要进入锁等待了
 9             if (_singleton == null)
10             {
11                 //加锁，保证任意时刻只有一个线程进入lock范围
12                 lock (_isLock)
13                 {
14                     Thread.Sleep(3000);
15                     Console.WriteLine("等待锁2s以后在继续...");
16                     //对象是否已经建立
17                     if (_singleton == null)
18                     {
19                         _singleton = new Singleton();
20                     }
21                 }
22             }
23             return _singleton;
24         }
25     }

 

　　2）饥饿模式

　　

 1 public class Hungry
 2     {
 3         private static Hungry _singleton = null;
 4         private static Hungry _singleton1 = new Hungry();
 5         /// <summary>
 6         /// 静态构造函数：由CLR保证，程序第一次使用这个类型前被调用一次，而且只调用一次
 7         /// 检测，初始化，
 8         /// 写日志功能的文件夹检测
 9         /// XML配置文件
10         /// </summary>
11         static Hungry()
12         {
13             _singleton = new Hungry();
14             Console.WriteLine($"Hungry 被启用...");
15         }
16 
17         /// <summary>
18         /// 恶汉模式，只要使用这个类就会被调用
19         /// </summary>
20         /// <returns></returns>
21         public static Hungry CreateIntance()
22         {
23             return _singleton;
24         }
25 
26         /// <summary>
27         /// 静态字段在第一次使用这个类以前，由CLR保证初始化而且只初始化一次（比构造函数还早）
28         /// 恶汉模式，只要使用这个类就会被调用
29         /// </summary>
30         /// <returns></returns>
31         public static Hungry CreateIntance1()
32         {
33             return _singleton1;
34         }
35     }