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

1. 懒汉模式（Lazy Loading）

懒汉模式是开源项目中使用最多的一种，最大的缺点是非线程安全的

type singleton struct {}// privatevar instance *singleton// publicfunc GetInstance() *singleton {    if instance == nil {
        instance = &singleton{}     // not thread safe
    }    return instance
}

2. 带锁的单例模式

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
}

这里使用了Go的sync.Mutex,其工作模型类似于Linux内核的futex对象，具体实现极其简单，性能也有保证
初始化时填入的0值将mutex设定在未锁定状态，同时保证时间开销最小
这一特性允许将mutex作为其它对象的子对象使用

3. 带检查锁的单例模式

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

这是一个不错的方法，但是还并不是很完美。因为编译器优化没有检查实例存储状态。如果使用sync/atomic包的话 就可以自动帮我们加载和设置标记。

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
}

4.比较好的一种方式sync.Once

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

引文：

https://xiequan.info/go%E7%9A%84%E5%8D%95%E4%BE%8B%E6%A8%A1%E5%BC%8F/

作者：iCaptain
链接：https://www.jianshu.com/p/d2fc1c998fc9