使用C# (.NET Core) 實現單體設計模式 (Singleton Pattern)

solenovex發表於2018-04-11
C#設計模式

本文的概念內容來自深入淺出設計模式一書

由於我在給公司做內培, 所以最近天天寫設計模式的文章….

單體模式 Singleton

單體模式的目標就是隻建立一個例項.

實際中有很多種物件我們可能只需要它們的一個例項, 例如: 執行緒池,快取, 彈出的對話方塊, 用於儲存設定的類, 用於logging的類, 硬體裝置驅動物件等等.

一段對話:

A: 如何建立一個物件?

B: new MyObject()

A: 如果想建立另一個物件, 就再次new MyObject()?

B: 是的

A: 所以說我們有某個類, 我們就可以對它例項化很多次?

B: 是的, 但是它必須是public的類額

A: 如果不是public的呢?

B: 如果不是public的, 那麼只有同一個包下的類才能對它例項化, 但是仍然可以例項化多次.

A: 嗯, 很有趣, 你只你可以這樣做嗎?

B: 沒見過, 但是語法是沒問題的, 存在即合理.

A: 它是什麼意思呢?

B: 我想它不能被例項化吧, 因為它的建構函式是private的啊.

A: 那麼, 有沒有哪個物件可以使用這個private的建構函式呢?

B: 額, 我認為只有MyClass裡面的程式碼可以呼叫這個建構函式, 但是感覺那沒什麼用啊.

A: 為什麼沒用呢?

B: 因為對類進行例項化, 就是想要用它的例項, 而這樣做的話, 別的類也無法對它進行例項化啊. 這是個雞和蛋的問題: 我可以使用MyClass裡面的建構函式, 但是我無法例項化這個物件, 因為其他的類無法使用 “new MyClass()”.

A: 你著確實是一種觀點, 那麼下面程式碼是什麼意思呢?

B: MyClass有一個靜態方法, 我們可以這樣呼叫靜態方法: MyClass.getInstance();

A: 為什麼使用MyClass, 而不是某個物件的名?

B: 因為getInstance()是靜態方法; 也就是說, 它是一個類方法, 你需要使用類名來呼叫方法.

A: 非常有趣, 那麼我把例項化程式碼放裡面呢?

B: 確實可以有這種操作…

A: 那麼, 現在你認為有第二種方法來例項化物件嗎?

B: MyClass.getInstance();

A: 那麼你現在能寫出只允許創造一個MyClass例項的程式碼了嗎?

B: 應該行.

 

經典單體模式的實現

首先需要有個靜態成員變數保留著例項的引用.

然後建構函式必須是私有的.

getInstance()方法可以該類進行例項化, 並且返回該例項.

另外, 該類也可以有其他方法.

裡面最重要的一部分程式碼:

如果該例項引用為null, 那麼建立一個例項, 並把這個例項賦給類的那個成員變數. 這裡要注意, 如果我們永遠不需要這個類的例項, 那麼這個類永遠也不會被例項化, 這叫做懶初始化.

如果例項引用不是null, 那麼就說明之前已經建立過該類的例項了, 那麼就返回之前建立的例項就行了.

 

一道巧克力工廠鍋爐的題

先看這個類:

開始的時候, 鍋爐是空的, 所以也沒有煮沸.

fill()方法(填充), 填充鍋爐的時候, 鍋爐必須是空的, 一旦填滿了, 那麼empty就改為false, 表示填滿了. 剛填滿肯定不是煮沸狀態, 所以boiled也是false.

drain()方法(抽取), 只有鍋爐是滿的並且煮沸之後才能抽取巧克力液體, 抽取完了, 鍋爐就又空了 empty改為true.

boil()方法(煮), 煮混合液體, 要求鍋爐的前提狀態必須是滿的 empty為false, 並且還沒煮沸 boiled為false. 一旦煮沸了, 就把boiled改成true.

這個工序很好, 但是必須保證只有一個鍋爐, 那麼該怎麼做? 請寫出程式碼.

單體模式定義

單體模式保證一個類只有一個例項, 並提供一個全域性訪問該例項的方法.

類圖:

 

其他問題

上面巧克力鍋爐那道題你可能寫好了, 但是可能會出現這個問題:

鍋爐可能在裡面有液體的情況下又進行了fill填充動作. 這是怎麼回事?

是不是其他執行緒引起的這個問題?

我們可能有兩個執行緒都在執行這段程式碼:

那麼兩個執行緒呼叫時是否有重疊, 程式碼執行是否有交錯?  請看下圖:

處理多執行緒問題

為了解決這個多執行緒的問題問題, 可已使用synchronized方法:

(synchronized是java裡的關鍵字, C#的請參考下面我寫的程式碼)

使用synchronized關鍵字以後, 每個執行緒必須等到輪到它的時候才能進入方法. 這樣兩個執行緒就不可能同時進入該方法了.

但是這種方法開銷很大, 這有時會成為一個問題. 而且可能比你想的更糟糕:

只有第一次執行該方法的時候synchronized才起作用, 一旦我們設定好了成員變數那個引用到具體的例項, 以後就不需要synchronized這個方法了, 除了第一次, 以後這就是額外的開銷.

還能改進多執行緒嗎

1. 如果效能不是那麼重要, 就繼續使用synchronized吧. 但是要記住使用synchronized之後執行速度可能會差100倍(JVM).

2. 那就不如早點把例項給建立出來, 而不是懶建立.

例如:

使用靜態的成員引用, 這樣類在載入的時候就把例項建立出來了(保證在任何執行緒訪問之前就會建立出來).

3. 使用”雙重檢查鎖”來減少對sync的使用.

這就是首先檢查例項是否被建立了, 如果沒有那麼進入sync塊. 第一建立例項的時候時sync的, 在塊裡面, 再檢查一次例項是否為null, 然後建立例項.

volatile關鍵字會保證被單體例項化的時候多執行緒會正確的處理uniqueInstance變數.

所以如果效能是問題, 就可以使用這個方法.

其他問題

Q: 如果我建立一個類, 裡面都是靜態方法和靜態變數, 那麼它的效果和單體模式不是一樣的嗎?

A: 是的, 如果你類沒有其他依賴並且初始化並不複雜的話.

Q: 可以繼承單體模式嗎?

A: 簡單的回答就是: No.

Q: 為什麼單體模式比全域性變數好?

A: 全域性變數會汙染名稱空間, 當然了單體模式寫不好也很爛.

總結

C# 實現

ChocolateBoiler:

namespace SingletonPattern
{
    public class ChocolateBoiler
    {
        public bool Empty { get; private set; }
        public bool Boiled { get; private set; }

        private static ChocolateBoiler _uniqueInstance;

        private ChocolateBoiler()
        {
            Empty = true;
            Boiled = false;
        }

        public static ChocolateBoiler GetInstance()
        {
            return _uniqueInstance ?? (_uniqueInstance = new ChocolateBoiler());
        }

        public void Fill()
        {
            if (Empty)
            {
                Empty = false;
                Boiled = false;
            }
        }

        public void Drain()
        {
            if (!Empty && Boiled)
            {
                Empty = true;
            }
        }

        public void Boil()
        {
            if (!Empty && !Boiled)
            {
                Boiled = true;
            }
        }
    }
}

 

SynchronizedChocolateBoiler:

using System.Runtime.CompilerServices;

namespace SingletonPattern
{
    public class SynchronizedChocolateBoiler
    {
        public bool Empty { get; private set; }
        public bool Boiled { get; private set; }

        private static SynchronizedChocolateBoiler _uniqueInstance;

        private SynchronizedChocolateBoiler()
        {
            Empty = true;
            Boiled = false;
        }

        [MethodImpl(MethodImplOptions.Synchronized)]
        public static SynchronizedChocolateBoiler GetInstance()
        {
            return _uniqueInstance ?? (_uniqueInstance = new SynchronizedChocolateBoiler());
        }

        public void Fill()
        {
            if (Empty)
            {
                Empty = false;
                Boiled = false;
            }
        }

        public void Drain()
        {
            if (!Empty && Boiled)
            {
                Empty = true;
            }
        }

        public void Boil()
        {
            if (!Empty && !Boiled)
            {
                Boiled = true;
            }
        }
    }
}

 

DoubleCheckChocolateBoiler:

namespace SingletonPattern
{
    public class DoubleCheckChocolateBoiler
    {
        public bool Empty { get; private set; }
        public bool Boiled { get; private set; }

        private static volatile DoubleCheckChocolateBoiler _uniqueInstance;
        private static readonly object LockHelper = new object();

        private DoubleCheckChocolateBoiler()
        {
            Empty = true;
            Boiled = false;
        }

        public static DoubleCheckChocolateBoiler GetInstance()
        {
            if (_uniqueInstance == null)
            {
                lock (LockHelper)
                {
                    if (_uniqueInstance == null)
                    {
                        _uniqueInstance = new DoubleCheckChocolateBoiler();
                    }
                }
            }
            return _uniqueInstance;
        }

        public void Fill()
        {
            if (Empty)
            {
                Empty = false;
                Boiled = false;
            }
        }

        public void Drain()
        {
            if (!Empty && Boiled)
            {
                Empty = true;
            }
        }

        public void Boil()
        {
            if (!Empty && !Boiled)
            {
                Boiled = true;
            }
        }
    }
}

由於這裡面提到了多執行緒, 所以我會另寫一篇關於C#/.NET Core非同步和多執行緒的文章(也會是書上的內容, 這本書叫 C# 7 in a Nutshell, 我認為這是最好的C#/.NET Core參考書, 可是沒有中文的, 所以我就是做一下翻譯和精簡)….

這個系列的程式碼我放在這裡了: https://github.com/solenovex/Head-First-Design-Patterns-in-CSharp

相關文章