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

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

單體模式 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;
            }
        }
    }
}

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