Go 单例模式

单例模式，是一种常用的软件设计模式，在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以包在系统中一个类只有一个实例且该实例易于访问，从而方便对实例个数的控制并节约系统资源。

懒汉模式(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
}