單例模式中不同語言的不同實現

coldplay.xixi
發布: 2020-10-14 17:37:20
轉載
2268 人瀏覽過

今天python影片教學欄位介紹單例模式中不同語言的不同實作。

單例模式中不同語言的不同實現

前言

前段時間在用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 可以透過類別變數達到變數在同一個類別中共享的效果,那是否可以實現單例模式?

可以利用 Pythonmetaclass 的特性,動態的控制類別的創建。

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)中是沒法類似於PythonJava 一樣可以宣告類別共享變數的;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 也能看到driverdriver1 引用的是同一個記憶體位址。

單例模式中不同語言的不同實現

這樣的實作常規情況是沒有什麼問題的,機智的朋友一定能想到和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 优雅许多;后续有机会再接着深入。

相关免费学习推荐:python视频教程

以上是單例模式中不同語言的不同實現的詳細內容。更多資訊請關注PHP中文網其他相關文章!

相關標籤:
來源:juejin.im
本網站聲明
本文內容由網友自願投稿,版權歸原作者所有。本站不承擔相應的法律責任。如發現涉嫌抄襲或侵權的內容,請聯絡admin@php.cn
作者最新文章
熱門教學
更多>
最新下載
更多>
網站特效
網站源碼
網站素材
前端模板