设计模式-单例模式详解

Posted 2022-08-02 hzhhhbb

一、引言

　　单例模式应该算是23种设计模式中比较简单的，它属于创建型的设计模式，关注对象的创建。

二、概念

　　单例模式是23个“Gang Of Four”的设计模式之一，它描述了如何解决重复出现的设计问题，以设计灵活且可复用的面向对象软件，使对象的实现、更改、测试和重用更方便。

单例模式解决了以下问题：

• 如何确保类只有一个实例？

• 如何轻松地访问类的唯一实例？

• 如何控制类的实例化？

• 如何限制类的实例数量？

单例模式是如何解决以上问题的呢？

• 隐藏类的构造函数。
• 定义一个返回类的唯一实例的公共静态操作。

这个设计模式的关键点在于使类控制其自身的实例化。

隐藏类的构造函数（定义私有构造函数）来确保类不能从外部实例化。

使用静态函数轻松访问类实例（Singleton.getInstance()）。

三、实现

1、懒汉式单例

 1 using System.Threading;
 2 
 3     public class SingletonTest
 4     
 5         private static SingletonTest instance = null;
 6 
 7         /// <summary>
 8         /// 隐藏类的构造函数（定义私有构造函数）来确保类不能从外部实例化
 9         /// </summary>
10         private SingletonTest()
11         
12             Console.WriteLine("******单例类被实例化******");
13         
14 
15         /// <summary>
16         /// 使用静态函数轻松访问类实例
17         /// </summary>
18         /// <returns><see cref="SingletonTest"/></returns>
19         public static SingletonTest GetInstance()
20         
21             if (instance == null)
22             
23                 instance = new SingletonTest();
24             
25 
26             return instance;
27         
28 
29         public void PrintSomething()
30         
31             Console.WriteLine($"当前线程Id为Thread.CurrentThread.ManagedThreadId");
32             Console.WriteLine("Singleton Pattern Test");
33         
34     

上述代码在单线程的情况下是能正常运行的，符合单例模式的定义。

但是，多线程的情况呢？

我们使用以下代码进行测试

 1 // 多线程情况
 2             for (int i = 0; i < 10; i++)
 3             
 4                 Task.Run(
 5                     () =>
 6                         
 7                             SingletonTest singleton1 = SingletonTest.GetInstance();
 8                             singleton1.PrintSomething();
 9                         );
10             

结果如下

不出所料，类SingletonTest被实例化了多次，不符合单例模式的要求，那如何解决这个问题呢？

既然是多线程引起的问题，那就要使用线程同步。我们在这里使用锁来实现。

 1     using System;
 2     using System.Threading;
 3 
 4     public class SingletonTest
 5     
 6         private static SingletonTest instance = null;
 7 
 8         private static object lockObject = new object();
 9 
10         /// <summary>
11         ///  隐藏类的构造函数（定义私有构造函数）来确保类不能从外部实例化
12         /// </summary>
13         private SingletonTest()
14         
15             Thread.Sleep(500);
16             Console.WriteLine("******单例类被实例化******");
17         
18 
19         /// <summary>
20         /// 使用静态函数轻松访问类实例
21         /// </summary>
22         /// <returns><see cref="SingletonTest"/></returns>
23         public static SingletonTest GetInstance()
24         
25             // 双重检查锁定的方式实现单例模式
26             if (instance == null)
27             
28                 lock (lockObject)
29                 
30                     if (instance == null)
31                     
32                         instance = new SingletonTest();
33                     
34                 
35             
36 
37             return instance;
38         
39 
40         public void PrintSomething()
41         
42             Console.WriteLine($"当前线程Id为Thread.CurrentThread.ManagedThreadId");
43             Console.WriteLine("Singleton Pattern Test");
44         
45     

上述代码在创建实例前，检查了两次实例是否为空，第一次判空是否有必要呢（上述代码26行）？为什么呢？我们想象这样的一种场景，在已经初始化类实例的情况下，是否还需要获取锁？答案是不需要，所以加第一个判断条件（上述代码26行）。

再次运行测试代码，结果如下：

 从结果来看，类只被实例化了一次，解决了多线程下类被多次实例化的问题。但是指令重排序是否对此有影响？是否需要volatile关键字？欢迎大佬来解答一下。

2、饿汉式单例（推荐）

第一种方式有点繁琐，可以简单点吗？如下

 1     using System;
 2     using System.Threading;
 3 
 4     public class SingletonTest2
 5     
 6         // 静态变量的方式实现单例模式
 7         private static readonly SingletonTest2 Instance = new SingletonTest2();
 8 
 9         private SingletonTest2()
10         
11             Thread.Sleep(1000);
12             Console.WriteLine("******单例类被实例化******");
13         
14 
15         public static SingletonTest2 GetInstance()
16         
17             return Instance;
18         
19 
20         public void PrintSomething()
21         
22             Console.WriteLine($"当前线程Id为Thread.CurrentThread.ManagedThreadId");
23             Console.WriteLine("Singleton Pattern Test");
24         
25     

这种实现方式利用的是.NET中静态关键字static的特性，使单例类在使用前被实例化，并且只实例化一次，这个由.NET框架保证。

这种方式存在问题，在没有使用到类中的成员时候就创建实例了，能否在使用到类成员的时候才创建实例呢？如下图

 1 using System;
 2     using System.Threading;
 3 
 4     public class SingletonTest2
 5     
 6         // 静态变量的方式实现单例模式
 7         private static readonly Lazy<SingletonTest2> Instance = new Lazy<SingletonTest2>(() => new SingletonTest2());
 8 
 9         private SingletonTest2()
10         
11             Thread.Sleep(1000);
12             Console.WriteLine("******初始化单例模式实例*****");
13         
14 
15         public static SingletonTest2 GetInstance()
16         
17             return Instance.Value;
18         
19 
20         public void PrintSomething()
21         
22             Console.WriteLine($"当前线程Id为Thread.CurrentThread.ManagedThreadId");
23             Console.WriteLine("Singleton Pattern Test");
24         
25     

我们使用了Lazy关键字来延迟实例化。

四、例外

值得注意的是，反射会破坏单例模式，如下代码，能直接调用类的私有构造函数，再次实例化。

1 // 反射破坏单例
2 var singletonInstance = System.Activator.CreateInstance(typeof(SingletonTest2), true);

怎么避免呢？类的实例化都需要调用构造函数，那么我们在构造函数中加入判断标识即可。尝试实例化第二次的时候，就会抛异常。

 1         private static bool isInstantiated;
 2 
 3         private SingletonTest2()
 4         
 5             if (isInstantiated)
 6             
 7                 throw new Exception("已经被实例化了，不能再次实例化");
 8             
 9 
10             isInstantiated = true;
11             Thread.Sleep(1000);
12             Console.WriteLine("******单例类被实例化******");
13         

五、应用

那么实际应用中，哪些地方应该用单例模式呢？在这个类只应该存在一个对象的情况下使用。哪些地方用到了单例模式呢？

• Windows任务管理器
• HttpContext.Current

六、总结

俗话说，凡事都有两面性。单例模式确保了类只有一个实例，也引入了其他问题：

• 单例模式中的唯一实例变量是使用static标记的，会常驻内存，不被GC回收，长期占用了内存
• 在多线程的情况下，使用的都是同一个实例，所以需要保证类中的成员都是线程安全，不然可能会导致数据混乱的情况

代码下载：https://github.com/hzhhhbb/SingletonPattern

七、参考资料

• https://en.wikipedia.org/wiki/Singleton_pattern
• https://docs.microsoft.com/zh-cn/dotnet/api/system.lazy-1?view=netcore-3.0