go 4種單例模式

懶漢式——非線程安全

非線程安全，指的是在多線程下可能會創建多次對象。

//使用結構體代替類
type Tool struct {
    values int
}

//建立私有變量
var instance *Tool

//獲取單例對象的方法，引用傳遞返回
func GetInstance() *Tool {
    if instance == nil {
        instance = new(Tool)
    }
    return instance
}

在非線程安全的基本上，利用 Sync.Mutex 進行加鎖保證線程安全，但由於每次調用該方法都進行了加鎖操作，在性能上不是很高效

//鎖對象
var lock sync.Mutex

//加鎖保證線程安全
func GetInstance() *Tool {
    lock.Lock()
    defer lock.Unlock()
    if instance == nil {
        instance = new(Tool)
    }

    return instance
}

餓漢式

直接創建好對象，不需要判斷為空，同時也是線程安全，唯一的缺點是在導入包的同時會創建該對象，並持續占有在內存中。

Go語言餓漢式可以使用 init 函數，也可以使用全局變量。

type cfg struct {
}
var cfg *config
func init()  {
   cfg = new(config)
}
// NewConfig 提供獲取實例的方法
func NewConfig() *config {
   return cfg
}
type config struct {  
}
//全局變量
var cfg *config = new(config)
// NewConfig 提供獲取實例的方法
func NewConfig() *config {
   return cfg
}

雙重檢查

在懶漢式（線程安全）的基礎上再進行優化，减少加鎖的操作，保證線程安全的同時不影響性能。

//鎖對象
var lock sync.Mutex

//第一次判斷不加鎖，第二次加鎖保證線程安全，一旦對象建立後，獲取對象就不用加鎖了。
func GetInstance() *Tool {
    if instance == nil {
        lock.Lock()
        if instance == nil {
            instance = new(Tool)
        }
        lock.Unlock()
    }
    return instance
}

sync.Once

通過 sync.Once 來確保創建對象的方法只執行一次

var once sync.Once

func GetInstance() *Tool {
    once.Do(func() {
        instance = new(Tool)

    })
    return instance
}

sync.Once 內部本質上也是雙重檢查的方式，但在寫法上會比自己寫雙重檢查更簡潔，以下是 Once 的源碼

func (o *Once) Do(f func()) {
　　//判斷是否執行過該方法，如果執行過則不執行
    if atomic.LoadUint32(&o.done) == 1 {
        return
    }
    // Slow-path.
    o.m.Lock()
    defer o.m.Unlock()
　　//進行加鎖，再做一次判斷，如果沒有執行，則進行標志已經掃行並調用該方法
    if o.done == 0 {
        defer atomic.StoreUint32(&o.done, 1)
        f()
    }
}