前言
前段時間在用 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 *MySQLDriver
func 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.Mutex
func 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.Once
func 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
優雅許多;後續有機會再接着深入。
參考鏈接: