設計模式-單例模式詳解

一、引言

　　單例模式應該算是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         ///  8         /// 隐藏類的構造函數（定義私有構造函數）來確定類不能從外部執行個體化 9         /// 10         private SingletonTest()11         {12             Console.WriteLine("******單例類被執行個體化******");13         }14 15         /// 16         /// 使用靜态函數輕松通路類執行個體17         /// 18         /// 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         /// 11         ///  隐藏類的構造函數（定義私有構造函數）來確定類不能從外部執行個體化12         /// 13         private SingletonTest()14         {15             Thread.Sleep(500);16             Console.WriteLine("******單例類被執行個體化******");17         }18 19         /// 20         /// 使用靜态函數輕松通路類執行個體21         /// 22         /// 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 LazyInstance = new Lazy(() => 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回收，長期占用了記憶體
• 在多線程的情況下，使用的都是同一個執行個體，是以需要保證類中的成員都是線程安全，不然可能會導緻資料混亂的情況