前段時間在用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
的 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
中如何實作單例。
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
优雅许多;后续有机会再接着深入。
相关免费学习推荐:python视频教程
以上是單例模式中不同語言的不同實現的詳細內容。更多資訊請關注PHP中文網其他相關文章!