今天欄目介紹單例模式中不同語言的不同實現。

前言

前段時間在用 Python 實現業務的時候發現一個坑，準確的來說是對於 Python 門外漢容易踩的坑；

大概程式碼如下：

class Mom(object):
    name = ''
    sons = []if __name__ == '__main__':
    m1 = Mom()
    m1.name = 'm1'
    m1.sons.append(['s1', 's2'])    print '{} sons={}'.format(m1.name, m1.sons)

    m2 = Mom()
    m2.name = 'm2'
    m2.sons.append(['s3', 's4'])    print '{} sons={}'.format(m2.name, m2.sons)複製程式碼

首先定義了一個 Mom 的類，它包含了一個字串型別的 name 與列表型別的 sons 屬性；

在使用時首先建立了該類的一個範例 m1 並往 sons 中寫入一個列表資料；緊接著又建立了一個範例 m2 ，也往 sons 中寫入了另一個列表資料。

如果是一個 Javaer 很少寫 Python 看到這樣的程式碼首先想到的輸出應該是：

m1 sons=[['s1', 's2']]
m2 sons=[['s3', 's4']]複製程式碼

但其實最終的輸出結果是：

m1 sons=[['s1', 's2']]
m2 sons=[['s1', 's2'], ['s3', 's4']]複製程式碼

如果想要達到期望值需要稍微修改一下：

class Mom(object):
    name = ''

    def __init__(self):
        self.sons = []複製程式碼

只需要修改類的定義就可以了，我相信即使沒有 Python 相關經驗對比這兩個程式碼應該也能猜到原因：

在 Python 中如果需要將變數作為範例變數（也就是每個我們期望的輸出）時，需要將變數定義到建構函式中，通過 self 存取。

如果只放在類中，和 Java 中的 static 靜態變數效果類似；這些資料由類共用，也就能解釋為什麼會出現第一種情況，因為其中的 sons 是由 Mom 類共用，所以每次都會累加。

Python 單例

既然 Python 可以通過類變數達到變數在同一個類中共用的效果，那是否可以實現單例模式呢？

可以利用 Python 的 metaclass 的特性，動態的控制類的建立。

class Singleton(type):
    _instances = {}    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)        return cls._instances[cls]複製程式碼

首先建立一個 Singleton 的基礎類別，然後我們在我們需要實現單例的類中將其作為 metaclass

class MySQLDriver:
    __metaclass__ = Singleton    def __init__(self):
        print 'MySQLDriver init.....'複製程式碼

這樣Singleton 就可以控制 MySQLDriver 這個類的建立了；其實在 Singleton 中的 __call__ 可以很容易理解這個單例建立的過程：

定義一個私有的類屬性 _instances 的字典（也就是 Java 中的 map）可以做到在整個類中共用，無論建立多少個範例。
當我們自定義類使用了 __metaclass__ = Singleton 後，便可以控制自定義類的建立了；如果已經建立了範例，那就直接從 _instances 取出物件返回，不然就建立一個範例並寫回到 _instances ，有點 Spring 容器的感覺。

if __name__ == '__main__':
    m1 = MySQLDriver()
    m2 = MySQLDriver()
    m3 = MySQLDriver()
    m4 = MySQLDriver()    print m1    print m2    print m3    print m4

MySQLDriver init.....
<__main__.MySQLDriver object at 0x10d848790>
<__main__.MySQLDriver object at 0x10d848790>
<__main__.MySQLDriver object at 0x10d848790>
<__main__.MySQLDriver object at 0x10d848790>複製程式碼

最後我們通過實驗結果可以看到單例建立成功。

Go 單例

由於最近團隊中有部分業務開始在用 go ，所以也想看看在 go 中如何實現單例。

type MySQLDriver struct {
    username string}複製程式碼

在這樣一個簡單的結構體（可以簡單理解為 Java 中的 class）中是沒法類似於 Python 和 Java 一樣可以宣告類共用變數的；go 語言中不存在 static 的概念。

但我們可以在包中宣告一個全域性變數來達到同樣的效果：

import "fmt"type MySQLDriver struct {
    username string}var mySQLDriver *MySQLDriverfunc GetDriver() *MySQLDriver {    if mySQLDriver == nil {
        mySQLDriver = &MySQLDriver{}
    }    return mySQLDriver
}複製程式碼

這樣在使用時：

func main() {
    driver := GetDriver()
    driver.username = "cj"
    fmt.Println(driver.username)

    driver2 := GetDriver()
    fmt.Println(driver2.username)

}複製程式碼

就不需要直接構造 MySQLDriver ，而是通過GetDriver() 函數來獲取，通過 debug 也能看到 driver 和 driver1 參照的是同一個記憶體地址。

這樣的實現常規情況是沒有什麼問題的，機智的朋友一定能想到和 Java 一樣，一旦並行存取就沒那麼簡單了。

在 go 中，如果有多個 goroutine 同時存取GetDriver() ，那大概率會建立多個 MySQLDriver 範例。

這裡說的沒那麼簡單其實是相對於 Java 來說的，go 語言中提供了簡單的 api 便可實現臨界資源的存取。

var lock sync.Mutexfunc GetDriver() *MySQLDriver {
    lock.Lock()    defer lock.Unlock()    if mySQLDriver == nil {
        fmt.Println("create instance......")
        mySQLDriver = &MySQLDriver{}
    }    return mySQLDriver
}func main() {    for i := 0; i < 100; i++ {        go GetDriver()
    }

    time.Sleep(2000 * time.Millisecond)
}複製程式碼

稍加改造上文的程式碼，加入了

lock.Lock()defer lock.Unlock()複製程式碼

程式碼就能簡單的控制臨界資源的存取，即便我們開啟了100個協程並行執行，mySQLDriver 範例也只會被初始化一次。

這裡的 defer 類似於 Java 中的 finally ，在方法呼叫前加上 go 關鍵字即可開啟一個協程。

雖說能滿足並行要求了，但其實這樣的實現也不夠優雅；仔細想想這裡

mySQLDriver = &MySQLDriver{}複製程式碼

建立範例只會呼叫一次，但後續的每次呼叫都需要加鎖從而帶來了不必要的開銷。

這樣的場景每個語言都是相同的，拿 Java 來說是不是經常看到這樣的單例實現：

public class Singleton {    private Singleton() {}   private volatile static Singleton instance = null;   public static Singleton getInstance() {        if (instance == null) {     
         synchronized (Singleton.class){           if (instance == null) {    
             instance = new Singleton();
               }
            }
         }        return instance;
    }
}複製程式碼

這是一個典型的雙重檢查的單例，這裡做了兩次檢查便可以避免後續其他執行緒再次存取鎖。

同樣的對於 go 來說也類似：

func GetDriver() *MySQLDriver {    if mySQLDriver == nil {
        lock.Lock()        defer lock.Unlock()        if mySQLDriver == nil {
            fmt.Println("create instance......")
            mySQLDriver = &MySQLDriver{}
        }
    }    return mySQLDriver
}複製程式碼

和 Java 一樣，在原有基礎上額外做一次判斷也能達到同樣的效果。

但有沒有覺得這樣的程式碼非常繁瑣，這一點 go 提供的 api 就非常省事了：

var once sync.Oncefunc GetDriver() *MySQLDriver {
    once.Do(func() {        if mySQLDriver == nil {
            fmt.Println("create instance......")
            mySQLDriver = &MySQLDriver{}
        }
    })    return mySQLDriver
}複製程式碼

本質上我們只需要不管在什麼情況下 MySQLDriver 範例只初始化一次就能達到單例的目的，所以利用 once.Do() 就能讓程式碼只執行一次。

檢視原始碼會發現 once.Do() 也是通過鎖來實現，只是在加鎖之前利用底層的原子操作做了一次校驗，從而避免每次都要加鎖，效能會更好。

總結

相信大家日常開發中很少會碰到需要自己實現一個單例；首先大部分情況下我們都不需要單例，即使是需要，框架通常也都有整合。

類似於 go 這樣框架較少，需要我們自己實現時其實也不需要過多考慮並行的問題；摸摸自己肚子左上方的位置想想，自己寫的這個物件真的同時有幾百上千的並行來建立嘛？

不過通過這個對比會發現 go 的語法確實要比 Java 簡潔太多，同時輕量級的協程以及簡單易用的並行工具支援看起來都要比 Java 優雅許多；後續有機會再接著深入。

相關免費學習推薦：

以上就是單例模式中不同語言的不同實現的詳細內容，更多請關注TW511.COM其它相關文章！