單例模式，是一種常用的軟體設計模式，在它的核心結構中只包含一個被稱為單例的特殊類。通過單例模式可以包在系統中一個類只有一個例項且該例項易於訪問，從而方便對例項個數的控制並節約系統資源。

懶漢模式(Lazy Loading)

   懶漢模式是開源專案中使用最多的一種，最大的缺點是非執行緒安全的。

type singleton struct {
}

// private
var instance *singleton

// public
func GetInstance() *singleton {
    if instance == nil {
        instance = &singleton{}     // not thread safe
    }
    return instance
}
 

type singleton struct {
}

var instance *singleton
var mu sync.Mutex

func GetInstance() *singleton {
    mu.Lock()
    defer mu.Unlock()

    if instance == nil {
        instance = &singleton{}     // unnecessary locking if instance already created
    }
    return instance
}

帶檢查鎖的單例模式

if instance == nil {     // <-- Not yet perfect. since it's not fully atomic
        mu.Lock()
        defer mu.Unlock()
 
        if instance == nil {
            instance = &singleton{}
        }
    }
    return instance
}
 

import "sync"
import "sync/atomic"

var initialized uint32
...

func GetInstance() *singleton {

    if atomic.LoadUInt32(&initialized) == 1 {
        return instance
    }

    mu.Lock()
    defer mu.Unlock()

    if initialized == 0 {
         instance = &singleton{}
         atomic.StoreUint32(&initialized, 1)
    }

    return instance
}
 

比較好的一種方式sync.Once

import (
    "sync"
)
 
type singleton struct {
}
 
var instance *singleton
var once sync.Once
 
func GetInstance() *singleton {
    once.Do(func() {
        instance = &singleton{}
    })
    return instance
}