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

時間 2019-11-18

標籤使用 c# core 實現單體設計模式 singleton pattern 欄目 C# 简体版

原文原文鏈接

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

因爲我在給公司作內培, 因此最近每天寫設計模式的文章....git

單體模式 Singleton

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

實際中有不少種對象咱們可能只須要它們的一個實例, 例如: 線程池,緩存, 彈出的對話框, 用於保存設置的類, 用於logging的類, 硬件設備驅動對象等等.shell

一段對話:設計模式

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;
            }
        }
    }
}