【并发编程】Once 基本用法和如何实现以及常见错误

博主介绍：

– 我是了 凡 微信公众号【了凡银河系】期待你的关注。未来大家一起加油啊~

---

前言

---

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语言内容一键三连后序每周持续更新！

---