C#設計模式學習筆記：(1)單例模式

    本筆記摘抄自：http://www.javashuo.com/article/p-vvpmrjym-bg.html，記錄一下學習過程以備後續查用。

    1、引言

    設計模式的分類：

    1）依目的：

    建立型（Creational）模式：負責對象建立

    結構型（Structural）模式：處理類與對象間的組合

    行爲型（Behavioral）模式：類與對象交互中的職責分配

    2）依範圍：

    類模式：處理類與子類的靜態關係

    對象模式：處理對象間的動態關係

    注：本系列文章依目的分類來進行。

    2、單例模式的介紹

    單例模式：英文名稱--Singleton Pattern；分類--建立型；定義--一個類僅有一個實例。

    2.一、動機（Motivate）

    在軟件系統中，常常有這樣一些特殊的類，必須保證它們在系統中只存在一個實例，才能確保它們的邏輯正確性、以及良好的效率。

    如何繞過常規的構造器，提供一種機制來保證一個類只有一個實例？這應該是類設計者的責任，而不是使用者的責任。

    2.二、意圖（Intent）

    保證一個類僅有一個實例，並提供一個該實例的全局訪問點。--《設計模式GoF》

    2.三、結構圖（Structure）

    2.四、模式組成

    這個模式裏面只有一個類型，就是Singleton類型，而且這個類只有一個實例，能夠經過Instance()方法獲取該類型的實例。

    2.五、代碼實現

    既然是單實例，確定會涉及到多線程的問題。

    2.5.1單線程Singleton模式的實現

    class Program
    {
        /// <summary>
        /// 單例模式的實現
        /// </summary>
        public sealed class Singleton
        {
            //定義一個靜態變量來保存類的實例
            private static Singleton uniqueInstance;

            //定義私有構造函數，使外界不能建立該類實例。
            private Singleton()
            {
                Console.WriteLine("Singleton對象已被建立。");
            }

            /// <summary>
            /// 定義公有方法提供一個全局訪問點，也能夠定義公有屬性來提供全局訪問點。
            /// </summary>
            /// <returns></returns>
            public static Singleton GetInstance()
            {
                //若是類的實例不存在則建立，不然直接返回。
                if (uniqueInstance == null)
                {
                    uniqueInstance = new Singleton();
                }
                return uniqueInstance;
            }
        }

        static void Main(string[] args)
        {
            #region (1)單例模式
            var singleton = Singleton.GetInstance();
            Console.Read();
            #endregion
        }
    }

View Code

    運行結果以下：

    私有的實例構造器是屏蔽外界的調用，上面的單例模式的實如今單線程下確實是完美的，也很好的知足了咱們單線程環境的需求。

    在多線程環境下，使用Singleton模式仍然有可能獲得Singleton類的多個實例對象。由於在兩個線程同時運行GetInstance方法時，

此時兩個線程判斷(uniqueInstance==null)這個條件時都返回真，此時兩個線程就都會建立Singleton的實例。

    2.5.2多線程Singleton模式的實現

    class Program
    {
        /// <summary>
        /// 單例模式的實現
        /// </summary>
        public sealed class Singleton
        {
            //定義一個靜態變量來保存類的實例
            private static volatile Singleton uniqueInstance;

            //定義一個標識確保線程同步
            private static readonly object locker = new object();

            //定義私有構造函數，使外界不能建立該類實例。
            private Singleton()
            {
                Console.WriteLine("Singleton對象已被建立。");
            }

            /// <summary>
            /// 定義公有方法提供一個全局訪問點，也能夠定義公有屬性來提供全局訪問點。
            /// </summary>
            /// <returns></returns>
            public static Singleton GetInstance()
            {
                //當第一個線程運行到這裏時，此時會對locker對象"加鎖"。
                //當第二個線程運行該方法時，首先檢測到locker對象爲"加鎖"狀態，該線程就會掛起等待第一個線程解鎖。
                //lock語句運行完以後（即線程運行完以後）會對該對象"解鎖"。
                lock (locker)
                {
                    // 若是類的實例不存在則建立，不然直接返回
                    if (uniqueInstance == null)
                    {
                        uniqueInstance = new Singleton();
                    }
                }
                return uniqueInstance;
            }
        }

        static void Main(string[] args)
        {
            #region (1)單例模式
            for (int i = 1; i <= 10; i++)
            {
                Thread thread = new Thread(new ParameterizedThreadStart(Worker));
                thread.Start(i);
            }
            Console.Read();
            #endregion
        }

        private static void Worker(object parameter)
        {
            Console.WriteLine($"Thread {parameter} is running.");
            Singleton.GetInstance();
        }
    }

View Code

    運行結果以下：

    上面的解決方案確實能夠解決多線程的問題，可是上面代碼每一個線程都會對線程輔助對象locker加鎖以後再判斷實例是否存在，這個是徹底沒有必要的。

由於當第一個線程建立了該類的實例以後，後面的線程此時只須要直接判斷（uniqueInstance==null）爲假便可，從而減小額外的開銷以提升性能。

    爲了改進上面實現方式的缺陷，咱們只須要在lock語句前面加一句（uniqueInstance==null）的判斷，這種雙層if加lock的實現方式，咱們稱它爲

「雙重鎖定（Double Check）」。

    class Program
    {
        /// <summary>
        /// 單例模式的實現
        /// </summary>
        public sealed class Singleton
        {
            //定義一個靜態變量來保存類的實例
            private static volatile Singleton uniqueInstance;

            //定義一個標識確保線程同步
            private static readonly object locker = new object();

            //定義私有構造函數，使外界不能建立該類實例。
            private Singleton()
            {
                Console.WriteLine("Singleton對象已被建立。");
            }

            /// <summary>
            /// 定義公有方法提供一個全局訪問點，也能夠定義公有屬性來提供全局訪問點。
            /// </summary>
            /// <returns></returns>
            public static Singleton GetInstance()
            {
                //當第一個線程運行到這裏時，此時會對locker對象"加鎖"。
                //當第二個線程運行該方法時，首先檢測到locker對象爲"加鎖"狀態，該線程就會掛起等待第一個線程解鎖。
                //lock語句運行完以後（即線程運行完以後）會對該對象"解鎖"。
                //雙重鎖定只須要一句判斷就能夠了
                if (uniqueInstance == null)
                {
                    lock (locker)
                    {
                        // 若是類的實例不存在則建立，不然直接返回
                        if (uniqueInstance == null)
                        {
                            uniqueInstance = new Singleton();
                        }
                    }
                }
                return uniqueInstance;
            }
        }

        static void Main(string[] args)
        {
            #region (1)單例模式
            for (int i = 1; i <= 10; i++)
            {
                Thread thread = new Thread(new ParameterizedThreadStart(Worker));
                thread.Start(i);
            }
            Console.Read();
            #endregion
        }

        private static void Worker(object parameter)
        {
            Console.WriteLine($"Thread {parameter} is running.");
            Singleton.GetInstance();
        }
    }

View Code

    volatile修飾：編譯器在編譯代碼的時候會對代碼的順序進行微調，用volatile修飾保證了嚴格意義的順序。一個定義爲volatile的變量是說這變量可能會

被意想不到地改變，這樣，編譯器就不會去假設這個變量的值了。精確地說就是，優化器在用到這個變量時必須每次都當心地從新讀取這個變量的值，而

不是使用保存在寄存器裏的備份。

    3、C#中實現了單例模式的類

    如今咱們看看，如何使用C#語言的特性來實現單例的Singleton模式。

        //Singleton模式的實現
        public sealed class Singleton
        {
            public static readonly Singleton instance = new Singleton();

            private Singleton() { }
        }

        //以上是內聯初始化（生成的同時進行初始化）的單例模式，它等同於：

        public sealed class Singleton
        {
            public static readonly Singleton instance;

            //靜態構造函數，CLR只執行一次。
            static Singleton()
            {
                instance = new Singleton();
            }

            //私有構造函數，防止外界調用
            private Singleton() { }
        }

    內聯初始化實際上是把靜態的字段放到靜態構造器去初始化。只要想訪問靜態字段，一定已經在使用以前先執行靜態構造器，這樣可以精確地保證使用

的時候必定能拿到實例，若是不使用也不會實例化對象，這也就是延時加載的功能。它一樣可以支持多線程環境，由於只可能有一個線程執行靜態構造

器，不存在多個線程去執行靜態構造器（感受就是程序已經自動爲咱們加鎖了）。

    它的一點弊端就是：靜態構造器只能聲明爲一個私有的、無參數的構造器，於是不支持參數化的實例化方法。

    須要說明的是：HttpContext.Current就是一個單例，它們是經過Singleton的擴展方式來實現的。

    4、Singleton模式的擴展

    1）將一個實例擴展到n個實例，例如對象池的實現。（n不是指無限個實例，而是固定的某個數。）

    2）將new構造器的調用轉移到其餘類中，例如多個類協同工做環境中，某個局部環境只須要擁有某個類的一個實例。

    3）理解和擴展Singleton模式的核心是「如何控制用戶使用new對一個類的實例構造器的任意調用」。

    5、單例模式的實現要點

    1）Singleton模式是限制而不是改進類的建立。

    2）Singleton類中的實例構造器能夠設置爲Protected以容許子類派生。

    3）Singleton模式通常不要支持Icloneable接口，由於這可能致使多個對象實例，與Singleton模式的初衷違背。

    4）Singleton模式通常不要支持序列化，這也有可能致使多個對象實例，這也與Singleton模式的初衷違背。

    5）Singleton只考慮對象建立的管理，沒有考慮銷燬的管理。爲何這樣作呢？由於Net平臺是支持垃圾回收的，因此咱們通常沒有必要對其進行銷燬

處理。

    6）理解和擴展Singleton模式的核心是「如何控制用戶使用new對一個類的構造器的任意調用」。

    7）能夠很簡單的修改一個Singleton，使它有少數幾個實例，這樣作是容許的並且是有意義的。

    5.1單例模式的優勢

    1）實例控制：Singleton會阻止其餘對象實例化其本身的Singleton對象的副本，從而確保全部對象都訪問惟一實例。

    2）靈活性：由於類控制了實例化過程，因此類能夠更加靈活修改實例化過程。

    5.2單例模式的缺點

    1）開銷：雖然數量不多，但若是每次對象請求引用時都要檢查是否存在類的實例，將仍然須要一些開銷，能夠經過使用靜態初始化解決此問題。

    2）可能的開發混淆：使用Singleton對象（尤爲在類庫中定義的對象）時，開發人員必須記住本身不能使用new關鍵字實例化對象。由於可能無

法訪問庫源代碼，所以應用程序開發人員可能會意外發現本身沒法直接實例化此類。

    3）對象的生存期：Singleton不能解決刪除單個對象的問題。由於它包含對該靜態的私有字段的引用，靜態字段是不能被CLR回收內存的，該實

例會和應用程序生命週期同樣長，一直存在。

    5.3單例模式的使用場合

    1）當類只能有一個實例並且客戶能夠從一個衆所周知的訪問點訪問它時。

    2）當這個惟一實例應該是經過子類化可擴展的，而且客戶應該無需更改代碼就能使用一個擴展的實例時。