單件模式（C#）

單件模式（C#）

2018-07-10 10:16

---

【原創】

本文地址：https://www.cnblogs.com/qiaoge0923/p/9282845.html

github示例代碼地址：https://github.com/JoySino/DesignPatternStudy/tree/master/ConsoleDemo/ConsoleDemo/Singleton

1.前言

單件模式保證一個類只有唯一一個實例，並提供一個全局訪問點。《設計模式——可復用面向對象軟件的基礎》中是這樣定義的：

類自身保存了該類的實例對象（自己創建實例），通過截取創建新實例的請求保證沒有其他新實例被創建(保證實例唯一)，並且提供一個全局訪問該實例對象的方法（對外提供唯一訪問點），這就是Singleton模式。

常用的場景如：

系統日志記錄器，系統配置管理器，模態窗口等等。

單件模式也允許子類繼承，目前未接觸到實際應用，暫無具體了解，所以下面的介紹均不考慮 子類擴展的情況。

2.普通懶漢單例模式

2.1代碼

    /// <summary>
    /// 多線程安全單例模式示例
    /// </summary>
    public sealed class LockSingleton
    {
        #region 單例

        private static LockSingleton _instance;
        /// <summary>
        /// 私有化構造函數，使得類不可通過new來創建實例
        /// </summary>
        private LockSingleton() { }

        //寫法1：通過屬性獲取實例
        public static LockSingleton Instance
        {
            get
            {
                if (_instance == null)
                {
                    _instance = new LockSingleton();
                }
                return _instance;
            }
        }

        //寫法2：通過方法獲取實例
        public static LockSingleton GetInstance()
        {
            //這里可以copy屬性Instance中的代碼
            return Instance;
        }
        #endregion
    }

2.2說明

這種寫法在多線程環境中會存在安全問題，兩個線程同時訪問時，都檢測到單例對象為空，所以都會執行初始化操作，這樣就會創建兩個實例對象來，無法做到唯一，所以一般不建議如此寫。

3.多線程安全單例模式

3.1代碼

    /// <summary>
    /// 多線程安全單例模式示例
    /// </summary>
    public sealed class LockSingleton
    {
        #region 字段

        public int normalX = SetValue(staticX);

        public static int staticX = 1;

        #endregion

        #region 單例

        private static LockSingleton _instance;
        private static readonly object lockObj = new object();
        /// <summary>
        /// 私有化構造函數，使得類不可通過new來創建實例
        /// </summary>
        private LockSingleton()
        {
            Console.WriteLine($"normalX={normalX}");
            Console.WriteLine($"staticX={staticX}");
            Console.WriteLine($"normalY={normalY}");
            Console.WriteLine($"staticY={staticY}");
        }

        //寫法1：通過屬性獲取實例
        public static LockSingleton Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (lockObj)
                    {
                        if (_instance == null)
                        {
                            _instance = new LockSingleton();
                        }
                    }
                }
                return _instance;
            }
        }

        //寫法2：通過方法獲取實例
        public static LockSingleton GetInstance()
        {
            //這里可以copy屬性Instance中的代碼
            return Instance;
        }
        #endregion

        #region 其他

        public int normalY = SetValue(staticY);

        public static int staticY = 1;

        private static int SetValue(int val)
        {
            return val;
        }

        #endregion
    }

3.2調用過程

     class Program
     {
         static void Main(string[] args)
         {
              Console.WriteLine("程序開始");
 
              Singleton.LockSingleton.GetInstance();
            
             Console.ReadKey();
         }
     }

3.3運行效果

3.4說明

 

normalX、staticX、normalY、staticY和Instance的執行順序為：外部調用》staticX 》staticY》單例對象_instance》normalX》normalY》私有構造函數。

使用懶漢式單例模式時必須要考慮多線程環境下的線程安全問題，本例中直接使用了線程安全的單例模式，鎖前鎖后雙重判斷，可以有效避免多線程同時讀到空單例對象可能導致創建多個實例對象的問題。

4.靜態初始化單例類示例1

4.1代碼

    /// <summary>
    /// 餓漢式單例類，靜態初始化單例類示例1
    /// </summary>
    public sealed class ReadonlySingleton
    {
        #region 字段

        public int normalX = SetValue(staticX);

        public static int staticX = 1;

        #endregion

        #region 單例
        /// <summary>
        /// 靜態初始化單例，只有通過這種寫法並且調用這個字段方能是餓漢式單例
        /// </summary>
        public static readonly ReadonlySingleton Instance = new ReadonlySingleton();

        /// <summary>
        /// 私有化構造函數，使得類不可通過new來創建實例
        /// </summary>
        private ReadonlySingleton()
        {
            Console.WriteLine($"normalX={normalX}");
            Console.WriteLine($"staticX={staticX}");
            Console.WriteLine($"normalY={normalY}");
            Console.WriteLine($"staticY={staticY}");
        }

        #endregion

        #region 其他

        public int normalY = SetValue(staticY);

        public static int staticY = 1;

        public void ShowLog()
        {
            Console.WriteLine($"{Common.TimeHelper.PrintMillisecond()}：ReadonlySingleton ShowLog");
        }

        private static int SetValue(int val)
        {
            return val;
        }

        #endregion
    }

4.2調用過程

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("程序開始");

            var tmp = Singleton.ReadonlySingleton.Instance;

            Console.ReadKey();
        }
    }

4.3運行效果

  

4.4說明

餓漢式單例類，在類加載的時候就會創建實例對象並一直存在於內存當中直至程序退出，所以，在Main函數的第一句執行前就已經執行了單例類的實例化。

normalX、staticX、normalY、staticY和Instance的執行順序為：staticX 》Instance》normalX》normalY》構造函數》staticY》外部調用。

可以看出，對於靜態字段，定義在單例字段前會先初始化，並在構造函數調用前執行，而定義在單例字段后會后初始化，並且在構造函數調用后執行；對於無修飾符的字段，無論位置在哪，都會在單例字段初始化后按順序初始化，並且在構造函數調用前執行。所以，normalY、staticY都打印了0而不是1。

單例字段Instance是公有的，可以外部訪問，只會實例化一次。這樣寫的單例類其字段會在類第一次使用前就初始化（具體時機由CLR決定），進而提前占用系統資源，如果想要在第一次訪問時再實例化對象，那么只需要把單例字段變成私有的，並提供外部訪問接口即可，或者定義內部類來實例化單例字段，詳情見靜態初始化單例類示例2、3、4。

5.靜態初始化單例類示例2（單例私有化）

5.1代碼

    public sealed class ReadonlySingleton2
    {
        #region 字段

        public int normalX = SetValue(staticX);

        public static int staticX = 1;

        #endregion

        #region 單例

        /// <summary>
        /// 靜態初始化單例，只有通過這種寫法並且調用這個字段方能是餓漢式單例
        /// </summary>
        private static readonly ReadonlySingleton2 _instance = new ReadonlySingleton2();
        /// <summary>
        /// 私有化構造函數，使得類不可通過new來創建實例
        /// </summary>
        private ReadonlySingleton2()
        {
            Console.WriteLine($"normalX={normalX}");
            Console.WriteLine($"staticX={staticX}");
            Console.WriteLine($"normalY={normalY}");
            Console.WriteLine($"staticY={staticY}");
        }

        //寫法1：通過屬性獲取實例
        public static ReadonlySingleton2 Instance
        {
            get { return _instance; }
        }

        //寫法2：通過方法獲取實例
        public static ReadonlySingleton2 GetInstance()
        {
            return _instance;
        }

        #endregion

        #region 其他

        public int normalY = SetValue(staticY);
        public static int staticY = 1;

        private static int SetValue(int val)
        {
            return val;
        }

        #endregion
    }

5.2調用過程

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("程序開始");

            var tmp = Singleton.ReadonlySingleton2.Instance;

            Console.ReadKey();
        }
    }

5.3運行效果

 

5.4說明

如此寫便可避免類一加載就實例化對象。當然還可以有其他寫法。

normalX、staticX、normalY、staticY和Instance的執行順序為：外部調用》staticX 》Instance》normalX》normalY》構造函數》staticY。

可以看出，單例類字段都是在外部第一次調用之后才初始化執行的，這種寫法實現了延遲加載。

6.靜態初始化單例類示例3(靜態構造函數)

6.1代碼

    public sealed class ReadonlySingleton3
    {
        #region 字段

        public int normalX = SetValue(staticX);

        public static int staticX = 1;

        #endregion

        #region 單例
        /// <summary>
        /// 靜態初始化單例，只有通過這種寫法並且調用這個字段方能是餓漢式單例
        /// </summary>
        public static readonly ReadonlySingleton3 Instance = new ReadonlySingleton3();

        /// <summary>
        /// 定義一個靜態構造函數，使得靜態字段在調用的時候才被初始化
        /// </summary>
        static ReadonlySingleton3()
        {
            Console.WriteLine("ReadonlySingleton3____Static");
        }
        /// <summary>
        /// 私有化構造函數，使得類不可通過new來創建實例
        /// </summary>
        private ReadonlySingleton3()
        {
            Console.WriteLine($"normalX={normalX}");
            Console.WriteLine($"staticX={staticX}");
            Console.WriteLine($"normalY={normalY}");
            Console.WriteLine($"staticY={staticY}");
        }

        #endregion

        #region 其他

        public int normalY = SetValue(staticY);

        public static int staticY = 1;

        public void ShowLog()
        {
            Console.WriteLine($"{Common.TimeHelper.PrintMillisecond()}：ReadonlySingleton3 ShowLog");
        }

        private static int SetValue(int val)
        {
            return val;
        }

        #endregion
    }

6.2調用過程

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("程序開始");

            var tmp = Singleton.ReadonlySingleton3.Instance;

            Console.ReadKey();
        }
    }

6.3運行效果

6.4說明

這里定義了一個靜態構造函數，使得同為靜態類型的單例類實例Instance在第一次調用時才進行初始化，也就達到了不提前占用系統資源的目的。不過在初始化單例類時，會先調用私有構造函數，然后再調用靜態構造函數。

normalX、staticX、normalY、staticY和Instance的執行順序為：外部調用》staticX 》Instance》normalX》normalY》私有構造函數》staticY》靜態構造函數。

可以看出，這樣寫也能達到延遲加載的目的。

7.靜態初始化單例類示例4(內部類)

7.1代碼

    public sealed class ReadonlySingleton4
    {
        #region 字段

        public int normalX = SetValue(staticX);

        public static int staticX = 1;

        #endregion

        #region 單例
        private class InnerInstance
        {
            internal static ReadonlySingleton4 _instance = new ReadonlySingleton4();
        }

        private ReadonlySingleton4()
        {
            Console.WriteLine($"normalX={normalX}");
            Console.WriteLine($"staticX={staticX}");
            Console.WriteLine($"normalY={normalY}");
            Console.WriteLine($"staticY={staticY}");
        }

        public static ReadonlySingleton4 Instance
        {
            get { return InnerInstance._instance; }
        }

        public static ReadonlySingleton4 GetInstance()
        {
            return InnerInstance._instance;
        }
        #endregion

        #region 其他

        public int normalY = SetValue(staticY);

        public static int staticY = 1;

        public void ShowLog()
        {
            Console.WriteLine($"{Common.TimeHelper.PrintMillisecond()}：ReadonlySingleton4 ShowLog");
        }

        private static int SetValue(int val)
        {
            return val;
        }

        #endregion
    }

7.2調用過程

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("程序開始");

            var tmp = Singleton.ReadonlySingleton4.Instance;

            Console.ReadKey();
        }
    }

7.3運行效果

7.4說明

normalX、staticX、normalY、staticY和Instance的執行順序為：外部調用》staticX 》staticY》內部類_instance》normalX》normalY》私有構造函數》內部類靜態構造函數（可以不用）。

內部類要不要構造函數和靜態構造函數都不影響，都能夠達到延遲加載的目的。

8.懶加載Lazy

8.1代碼

    /// <summary>
    /// 使用Lazy創建單例類示例
    /// </summary>
    public sealed class LazySingleton
    {
        #region 字段

        public int normalX = SetValue(staticX);

        public static int staticX = 1;

        #endregion

        #region 單例
        private static readonly Lazy<LazySingleton> _instance = new Lazy<LazySingleton>(() => new LazySingleton());

        private LazySingleton()
        {
            Console.WriteLine($"normalX={normalX}");
            Console.WriteLine($"staticX={staticX}");
            Console.WriteLine($"normalY={normalY}");
            Console.WriteLine($"staticY={staticY}");
        }

        //寫法1：通過屬性獲取實例
        public static LazySingleton Instance
        {
            get
            {
                return _instance.Value;
            }
        }

        //寫法2：通過方法獲取實例
        public static LazySingleton GetInstance()
        {
            return _instance.Value;
        }
        #endregion

        #region 其他

        public int normalY = SetValue(staticY);

        public static int staticY = 1;

        private static int SetValue(int val)
        {
            return val;
        }

        #endregion
    }

8.2調用過程

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("程序開始");

            var tmp = Singleton.LazySingleton.Instance;

            Console.ReadKey();
        }
    }

8.3運行效果

8.4說明

normalX、staticX、normalY、staticY和Instance的執行順序為：外部調用》staticX 》單例對象_instance》staticY》normalX》normalY》私有構造函數。

9.總結

單例模式實現方式很多種，上面只是常用的幾種。我認為最適合使用的非"單例私有化"的寫法，既避免了多線程安全問題，又能延遲加載，避免提前占用系統資源。

學習了單例模式，接下來繼續工廠模式的學習。