博主介绍：
– 我是了 凡 微信公众号【了凡银河系】期待你的关注。未来大家一起加油啊~
前言
Once是什么能做什么？
Once可以用来执行且仅仅执行一次动作，常常用于单例对象的初始化场景。
初始化单例资源有很多方法，比如定义package级别的变量，这样程序在启动的时候就可以初始化：
package abc
import time
var startTime = time.Now()
或者在init函数中进行初始化：
package abc
var startTime time.Time
func init(){
startTtime = time.Now()
}
又或者在main函数开始执行的时候，执行一个初始化的函数：
package abc
var startTime = time.Now()
func initApp() {
startTtime = time.Now()
}
func main() {
initApp()
}
这三种方法都是线程安全的，并且后两种方法还可以根据传入的参数实现定制化的初始化操作。（可是这个和Once有什么关系呢，别着急，记住Once可以用来执行且仅仅执行一次动作）
但是很多时候我们是要延迟初始化的，所以有时候单列资源的初始化，我们会使用下面的方法：
// 使用互斥锁保证线程(goroutine)安全
var connMu sync.Mutex
var conn net.Conn
func getConn() net.Conn {
connMu.Lock()
defer connMu.Unlock()
// 返回已创建好的连接
if conn != nil {
return conn
}
// 创建连接
conn, _ = net.DialTimeout("tcp","baidu.com:80", 10*time.Second)
return conn
}
func main() {
conn := getConn()
if conn == nil {
panic("conn is nil")
}
}
这种方式虽然实现起来简单，但是有性能问题。一旦连接创建好，每次请求的时候还是得竞争锁才能读取到这个连接，这是比较浪费资源的，因为连接如果创建好之后，其实不需要锁的保护了。所以Once并发原语就体现出它的价值了。
Once基础用法以及使用场景
sync.Once只暴露了一个方法Do，你可以多次调用Do方法，但是只有第一次调用Do方法时f参数才会执行，这里的f是一个无参数无返回值的函数。
func (0 *Once) Do(f func())
因为当且仅当第一次调用Do方法的时候参数f才会执行，即使第二次、第三次、第n次调用时f参数的值不一样，也不会被执行，比如下面的例子，虽然f1和f2是不同的函数，但是第二个函数f2就不会执行。
func main() {
var once sync.Once
// 第一个初始化函数
f1 := func() {
fmt.Println("in f1")
}
once.Do(f1) // 打印出 in f1
// 第二个初始化函数
f2 := func() {
fmt.Println("in f2")
}
once.Do(f2) // 无输出
}
因为这里的f参数是一个无参数无返回的函数，所以你可能会通过闭包的方式引用的参数，比如：
var adr = "baidu.com"
var conn net.Conn
var err error
once.Do(func() {
conn, err = net.Dial("tcp", addr)
})
而且在实际的使用中，绝大多数情况下，你会使用闭包的方式去初始化外部的一个资源。
Once的使用场景很明确，在标准库内部实现中也常常看到Once的身影
例如标准库内部 cache的实现上，就使用了Once初始化Cache资源，包括defaultDir值的获取：
func Default() *cache.Cache { // 获取默认的Cache
defaultOnce.Do(initDefaultCache) // 初始化cache
return defaultCache
}
// 定义一个全局的cache变量，使用Once初始化，所以也定义了一个Once变量
var (
defaultOnce sync.Once
defaultCache *cache.Cache
)
func initDefaultCache() { // 初始化cache，也就是Once.Do使用的f函数
.......
defaultCache = c
}
// 其他一些Once初始化变量，比如defaultDir
var (
defaultDirOnce sync.Once
defaultDir string
defaultDirErr error
)
还有一些测试的时候初始化测试的资源（export_windows_test）:
// 测试window系统调用时区相关函数
func ForceAusFromTZIForTesting() {
ResetLocalOnceForTest()
// 使用Once执行一次初始化
localOnce.Do(func() { initLocalFromTZI(&aus) })
}
除此之外，还要保证只调用一次copyenv的envOnce，strings包下的Replacer，time包中的测试，Go拉取库时的proxy，net.pipe，crc64，Regexp，…，数不胜数。了解一个math/big/sqrt.go中实现的一个数据结构，它通过Once封装了一个只初始化一次的值：
// 值是3.0或者0.0的一个数据结构
var threeOnce struct {
sync.Once
v *Float
}
// 返回此数据结构的值，如果还没有初始化为3.0, 则初始化
func three() *Float {
threeOnce.Do(func() { // 使用Once初始化
threeOnce.v = NewFloat(3.0)
}
}
将sync.Once和*Float封装成一个对象，提供了只初始化一次的值v。看它的three方法的实现，虽然每次都调用threeOnce.Do方法，但是参数只会调用一次。
总结
Once并发原语解决的问题和使用场景：Once常常用来初始化单例资源，或者并发访问只需初始化一次的共享资源，或者在测试的时候初始化一次测试资源。
Once如何实现
通过上述的问题你大概应该明白Once是什么以及怎么用了，但是实现的话，也许会像我们想的很简单，比如只需使用一个flag标记是否初始化过即可，最多是用atomic原子操作这个flag，比如下面的实现：
type Once struct {
done uint32
}
func (o *Once) Do(f func()) {
if !atomic.CompareAndSwapUint32(&o.done, 0, 1) {
return
}
f()
}
这样是一种实现方式，但是，这个实现有一个很大的问题，就是如果参数f执行很慢的话，后续调用Do方法的goroutine虽然看到done已经设置为执行过了，但是获取某些初始化资源的时候可能会得到空的资源，因为f还没有执行完。
所以，一个正确的Once实现要使用一个互斥锁，这样初始化的时候如果有并发的goroutine，就会进入doSlow方法。互斥锁的机制保证只有一个goroutine进行初始化，同时利用双检查的机制(double-checking)，再次判断o.done是否为0，如果为0，则是第一次执行，执行完毕后，就将o.done设置为1，然后释放锁。
即使此时有多个goroutine同时进入了doSlow方法，因为双检查的机制，后续的goroutine会看到o.done的值为1，也不会再次执行f。
这样的话既保证了并发的goroutine会等待f完成，而且还不会多次执行f。
type Once struct {
done uint32
m sync.Mutex
}
func (o *Once) Do(f func()) {
if atomic.LoadUint32(&o.done) == 0 {
o.doSlow(f)
}
}
func (o *Once) doSlow(f func()) {
o.m.Lock()
defer o.m.Unlock()
// 双检查
if o.done == 0 {
defer atomic.StoreUint32(&o.done, 1)
f()
}
}
这样呢，基本上我认为了解基本可以了，尽管有些地方还不是很懂，但是对于Once已经可以称为了解了。
使用Once的错误
第一种：死锁
Do方法会执行一次f，但是如果f中再次调用这个Once的Do方法的话，就会导致死锁的情况出现。这还不是无限递归的情况，而是Lock的递归调用导致的死锁。
func main() {
var once sync.once
once.Do(func() {
once.Do(func() {
fmt.Println("初始化")
})
})
}
想要避免这种情况的出现，就不要在f参数中调用当前的这个Once，不管是直接的还是间接的。
第二种： 未初始化
如果f方法执行的时候panic，或者f执行初始化资源的时候失败了，这个时候，Once还是会认为已经成功了，即使再次调用方法，也不会再次执行f。
比如：由于一些防火墙的原语，googleConn并没有被正确的初始化，后面如果想当然认为既然执行了Do方法googleConn就已经初始化的话，会抛出空指针的错误：
func main() {
var once sync.Once
var googleConn net.Conn // 到Google网站的一个连接
once.Do(func() {
// 建立到google.com的连接，有可能因为网络的原语，googleConn并没有建立成功，此时它的值为nil
googleConn,_ = net.Dial("tcp","google.com:80")
})
// 发送http请求
googleConn.Write([]byte("GET / HTTP/1.1\r\nHost: google.com/r/n Accept: */*\r\n\r\n"))
io.Copy(os.Stdout.GoogleConn)
}
执行过Once.Do方法也可能因为函数执行失败的原因未初始化资源，并且以后也没有机会再次初始化资源，那么这种初始化未完成的问题该怎么解决呢？
解法：可以自己实现一个类似Once的并发原语，既可以返回当前调用Do方法是否正确完成，还可以在初始化失败后调用Do方法再次尝试初始化，直到初始化成功才不再初始化了。
// 一个功能更加强大的Once
type Once struct {
m sync.Mutex
done uint32
}
// 传入的函数f有返回值error，如果初始化失败，需要返回失败的error
// Do方法会把这个error返回给调用者
func (o *Once) Do(f fucn() error) error {
if atomic.LoadUint32(&o.done) == 1 { // fast path
return nil
}
return o.slowDo(f)
}
// 如果还没有初始化
func (o *Once) slowDo(f func() error) error {
o.m.Lock()
defer o.m.Unlock()
var err error
if o.done == 0 { // 双检查，还没有初始化
err = f()
if err == nil { // 初始化成功才将标记置为已初始化
atomic.StoreUint32(&o.done, 1)
}
}
return err
}
改变的地方就是Do方法和参数f函数都会返回error，如果f执行失败，会把这个错误信息返回。
对slowDo方法也做了调整，如果f调用失败，不会更改done字段的值，这样后续degoroutine还会继续调用f。如果f执行成功，才会修改done的值为1。
这个时候有了一个新的问题，怎么查询是否初始化过呢？
type AnimalStore struct {
once sync.Once; inited uint32
}
func (a *AnimalStore) Init() // 可以被并发调用
a.once.Do(func() {
longOperationSetupdbOpenFilesQueuesEtc()
atomic.StoreUint32(&a.inited, 1)
})
}
func (a *AnimalStore) CountOfCats() (int, error) { // 另外一个goroutine
if atomic.LoadUint32(&a.inited) == 0 {
return 0, NotYetInitedError
}
// Real operation
}
这样就解决掉了以上的问题
总结Once常常用来实现单例模式。
单例是23种设计模式之一，也是常常引起争议的设计模式之一，甚至有人把它归为反模式。为什么是反模式？（例如标准库钟的单例模式）
因为Go没有immutable类型，导致我们声明的全局变量都是可变的，别的地方或者第三方库可以随意更改这些变量。比如package io 中定义了几个全局变量，比如 io.EOF:
var EOF = errors.NEW("EOF")
因为它是一个package级别的变量，我们可以在程序中把它改了，这会导致一些依赖 io.EOF 这个变量做判断的代码出错。
io.EOF = errors.New("我们自己定义的EOF")
-
一些单例（全局变量）的确很方便，比如Buffer池或者连接池，所以有时候我们也不要谈虎色变。虽然有人把单例模式称之为反模式，但毕竟只能代表一部分开发者的观点，否则越不会在23种设计模式中了。
-
如果真的担心这个package级别的变量被人修改，可以不把它们暴露出来，而是提供一个只读的GetXXX的方法，这样别人就不会进行修改了。
-
而且，Once不只应用于单例模式，一些变量在也需要在使用的时候做延迟初始化，所以也是可以使用Once处理这些场景的。
-
所以，Once的应用场景很广泛。一旦遇到只需要初始化一次的场景，首先想到的就应该是Once并发原语。
这次就先讲到这里，如果想要了解更多的golang语言内容一键三连后序每周持续更新！
