C#Singleton模式實現(xiàn)方法及案例

不懂C#Singleton模式實現(xiàn)方法及案例？其實想解決這個問題也不難，下面讓小編帶著大家一起學(xué)習(xí)怎么去解決，希望大家閱讀完這篇文章后大所收獲。

前言

Singleton是二十三個設(shè)計模式中比較重要也比較經(jīng)常使用的模式。但是這個模式雖然簡單，實現(xiàn)起來也會有一些小坑，讓我們一起來看看吧！

實現(xiàn)思路

首先我們看看這個設(shè)計模式的UML類圖。

很清晰的可以看到，有三點是需要我們在實現(xiàn)這個模式的時候注意的地方。

• 私有化的構(gòu)造器
• 全局唯一的靜態(tài)實例
• 能夠返回全局唯一靜態(tài)實例的靜態(tài)方法
   

其中，私有化構(gòu)造器是防止外部用戶創(chuàng)建新的實例而靜態(tài)方法用于返回全局唯一的靜態(tài)實例供用戶使用。原理清楚了，接下來我們看看一些典型的實現(xiàn)方式和其中的暗坑。

實現(xiàn)方法

最簡單的實現(xiàn)方法

最簡單的實現(xiàn)方法自然就是按照UML類圖直接寫一個類，我們看看代碼。

 class Program
 {
  static void Main(string[] args)
  {
  	var single1 = Singleton.Instance;
   var single2 = Singleton.Instance;
   Console.WriteLine(object.ReferenceEquals(single1, single2));
   Console.ReadLine();
  }
 }

 class Singleton
 {
  private static Singleton _Instance = null;
  private Singleton()
  {
   Console.WriteLine("Created");
  }

  public static Singleton Instance
  {
   get
   {
    if (_Instance == null)
    {
     _Instance = new Singleton();
    }
    return _Instance;
   }
  }

  public void DumbMethod()
  {

  }
 }

這段代碼忠實的實現(xiàn)了UML類圖里面的一切，查看輸出結(jié)果，

證實了Singleton確實起了作用，多次調(diào)用僅僅產(chǎn)生了一個實例，似乎這么寫就可以實現(xiàn)這個模式了。但是，真的會那么簡單嗎？

如果多線程亂入？

現(xiàn)在我們給剛剛的例子加點調(diào)料，假設(shè)多個對實例的調(diào)用，并不是簡單的，彬彬有禮的順序關(guān)系，二是以多線程的方式調(diào)用，那么剛剛那種實現(xiàn)方法，還能從容應(yīng)對嗎？讓我們試試。把Main函數(shù)里面的調(diào)用改成這樣。

	static void Main(string[] args)
  {
   int TOTAL = 10000;
   Task[] tasks = new Task[TOTAL];
   for (int i = 0; i < TOTAL; i++)
   {
    tasks[i] = Task.Factory.StartNew(() =>
    {
     Singleton.Instance.DumbMethod();
    });
   }
			Task.WaitAll(tasks);
   Console.ReadLine();
  }

通過Factory創(chuàng)造出1萬個Task，幾乎同時去請求這個單例，看看輸出。

咦，我們剛剛寫的Singleton模式失效了，這個類被創(chuàng)造了5次（這段代碼運行多次，這個數(shù)字不一定相同），一定是多線程搞的鬼，我們剛剛寫的代碼沒有辦法應(yīng)對多線程，換句話說，是非線程安全的(thread-safe)，那有沒有辦法來攻克這個難關(guān)呢？

線程安全的單例模式

Lock版本

提到線程安全，很多同學(xué)第一反應(yīng)就是用lock，不錯，lock是個可行的辦法，讓我們試試。添加一個引用類型的對象作為lock對象，修改代碼如下（什么？你問我為什必須是引用類型的對象而不能是值類型的對象？因為lock的時候，如果對象是值類型，那么lock僅僅鎖住了它的一個副本，另外一個線程可以暢通無阻的再次lock，這樣lock就失去了阻塞線程的意義）

	private static object _SyncObj = new object();
  public static Singleton Instance
  {
   get
   {
    lock (_SyncObj)
    {
     if (_Instance == null)
     {
      _Instance = new Singleton();
     }
     return _Instance;
    }    
   }
  }

運行一下，輸出

只有一個實例創(chuàng)建，證明Lock起作用了，這個模式可行！不過有些不喜歡用Lock的同學(xué)可能要問，還有沒有其他辦法呢？答案是有的。

靜態(tài)構(gòu)造器版本

回想一下，C#中的類靜態(tài)構(gòu)造器，只會在這個類第一次被使用的時候調(diào)用一次，天然的線程安全，那我們試試不用Lock使用類靜態(tài)構(gòu)造器？修改Singleton類如下：

 class Singleton
 {
  private static Singleton _Instance = null;
  private Singleton()
  {
   Console.WriteLine("Created");
  }

  static Singleton()
  {
   _Instance = new Singleton();
  }

  //private static object _SyncObj = new object();
  public static Singleton Instance
  {
   get { return _Instance; }
  }

  public void DumbMethod()
  {

  }
 }

去掉了Lock，添加了一個類靜態(tài)構(gòu)造器，試一試。

完美！對于不喜歡用Lock（在這個例子中，實例只會創(chuàng)建一次但是之后的所有線程都要先排隊Lock再進入Critical code進行檢查，效率比較低下）的同學(xué)，類靜態(tài)構(gòu)造器提供了一種很好的選擇。
不過俗話說，人心苦不足 ， 我們總是追求卓越。這個版本比Lock版本似乎更好一點，那還有沒有更好的版本呢？有的。

Lazy版本

從net 4.0開始，C#開始支持延遲初始化，通過Lazy關(guān)鍵字，我們可以聲明某個對象為僅僅當(dāng)?shù)谝淮问褂玫臅r候，再初始化，如果一直沒有調(diào)用，那就不初始化，省去了一部分不必要的開銷，提升了效率。如果你不熟悉Lazy或者想更多了解它，請參考。我們今天關(guān)注的重點在于，Lazy也是天生線程安全的，所以我們嘗試用它來實現(xiàn)Singleton模式？修改代碼如下：

 class Singleton
 {
  private static Lazy<Singleton> _Instance = new Lazy<Singleton>(() => new Singleton());
  private Singleton()
  {
   Console.WriteLine("Created");
  }

  public static Singleton Instance
  {
   get
   {
    return _Instance.Value;
   }
  }

  public void DumbMethod()
  {

  }
 }

輸出結(jié)果中可以看到，我們達(dá)到了想要的效果：

在上面的代碼中，私有變量_Instance現(xiàn)在是被聲明為延遲初始化，這樣不但天然實現(xiàn)了線程安全，同時在沒有調(diào)用Instance靜態(tài)方法的時候（也即沒有調(diào)用_Instance.Value），初始化不會發(fā)生，這樣就提高了效率。

Singleton模式很常見，實現(xiàn)起來也很簡單，只是要小心線程安全。以上三種方法都可以實現(xiàn)線程安全的Singleton模式。如果net 版本在4.0之上，建議使用Lazy版本，畢竟對比Lock版本，Lazy版本可以免去實現(xiàn)手動Lock之苦，對比Static版本，又有延遲初始化的性能優(yōu)勢，何樂而不為呢？

感謝你能夠認(rèn)真閱讀完這篇文章，希望小編分享C#Singleton模式實現(xiàn)方法及案例內(nèi)容對大家有幫助，同時也希望大家多多支持億速云，關(guān)注億速云行業(yè)資訊頻道，遇到問題就找億速云，詳細(xì)的解決方法等著你來學(xué)習(xí)!